chore(models): common Server & Servers for all providers (#943)

internal/updater/providers/cyberghost/hosttoserver.go

@@ -7,7 +7,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.CyberghostServer
+type hostToServer map[string]models.Server
 
 func getPossibleServers() (possibleServers hostToServer) {
 	groupIDToProtocol := getGroupIDToProtocol()
@@ -24,7 +24,7 @@ func getPossibleServers() (possibleServers hostToServer) {
 		for countryCode, country := range possibleCountryCodes {
 			const domain = "cg-dialup.net"
 			possibleHost := groupID + "-" + countryCode + "." + domain
-			possibleServer := models.CyberghostServer{
+			possibleServer := models.Server{
 				Hostname: possibleHost,
 				Country:  country,
 				TCP:      protocol == constants.TCP,
@@ -58,8 +58,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toSlice() (servers []models.CyberghostServer) {
-	servers = make([]models.CyberghostServer, 0, len(hts))
+func (hts hostToServer) toSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/cyberghost/servers.go

@@ -10,7 +10,7 @@ import (
 )
 
 func GetServers(ctx context.Context, presolver resolver.Parallel,
-	minServers int) (servers []models.CyberghostServer, err error) {
+	minServers int) (servers []models.Server, err error) {
 	possibleServers := getPossibleServers()
 
 	possibleHosts := possibleServers.hostsSlice()

internal/updater/providers/cyberghost/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.CyberghostServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Country == servers[j].Country {
 			return servers[i].Hostname < servers[j].Hostname

internal/updater/providers/expressvpn/hardcoded.go

@@ -5,8 +5,8 @@ import (
 )
 
 //nolint:lll
-func hardcodedServers() (servers []models.ExpressvpnServer) {
-	return []models.ExpressvpnServer{
+func hardcodedServers() (servers []models.Server) {
+	return []models.Server{
 		{Country: "Albania", Hostname: "albania-ca-version-2.expressnetw.com"},
 		{Country: "Algeria", Hostname: "algeria-ca-version-2.expressnetw.com"},
 		{Country: "Andorra", Hostname: "andorra-ca-version-2.expressnetw.com"},

internal/updater/providers/expressvpn/servers.go

@@ -16,7 +16,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.ExpressvpnServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	servers = hardcodedServers()
 
 	hosts := make([]string, len(servers))

internal/updater/providers/expressvpn/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.ExpressvpnServer) {
+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 {

internal/updater/providers/fastestvpn/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.FastestvpnServer
+type hostToServer map[string]models.Server
 
 func (hts hostToServer) add(host, country string, tcp, udp bool) {
 	server, ok := hts[host]
@@ -44,8 +44,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.FastestvpnServer) {
-	servers = make([]models.FastestvpnServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/fastestvpn/servers.go

@@ -18,7 +18,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.FastestvpnServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	const url = "https://support.fastestvpn.com/download/openvpn-tcp-udp-config-files"
 	contents, err := unzipper.FetchAndExtract(ctx, url)
 	if err != nil {

internal/updater/providers/fastestvpn/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.FastestvpnServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Country == servers[j].Country {
 			return servers[i].Hostname < servers[j].Hostname

internal/updater/providers/hidemyass/servers.go

@@ -16,7 +16,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, client *http.Client,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.HideMyAssServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	tcpHostToURL, udpHostToURL, err := getAllHostToURL(ctx, client)
 	if err != nil {
 		return nil, nil, err
@@ -34,7 +34,7 @@ func GetServers(ctx context.Context, client *http.Client,
 		return nil, warnings, err
 	}
 
-	servers = make([]models.HideMyAssServer, 0, len(hostToIPs))
+	servers = make([]models.Server, 0, len(hostToIPs))
 	for host, IPs := range hostToIPs {
 		tcpURL, tcp := tcpHostToURL[host]
 		udpURL, udp := udpHostToURL[host]
@@ -50,7 +50,7 @@ func GetServers(ctx context.Context, client *http.Client,
 		}
 		country, region, city := parseOpenvpnURL(url, protocol)
 
-		server := models.HideMyAssServer{
+		server := models.Server{
 			Country:  country,
 			Region:   region,
 			City:     city,

internal/updater/providers/hidemyass/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.HideMyAssServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Country == servers[j].Country {
 			if servers[i].Region == servers[j].Region {

internal/updater/providers/ipvanish/hosttoserver.go

@@ -7,7 +7,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.IpvanishServer
+type hostToServer map[string]models.Server
 
 func (hts hostToServer) add(host, country, city string, tcp, udp bool) {
 	server, ok := hts[host]
@@ -49,8 +49,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.IpvanishServer) {
-	servers = make([]models.IpvanishServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/ipvanish/hosttoserver_test.go

@@ -47,7 +47,7 @@ func Test_hostToServer_add(t *testing.T) {
 			udp:     true,
 			expectedHTS: hostToServer{
 				"existing host": {},
-				"host": models.IpvanishServer{
+				"host": models.Server{
 					Hostname: "host",
 					Country:  "country",
 					City:     "city",
@@ -58,7 +58,7 @@ func Test_hostToServer_add(t *testing.T) {
 		},
 		"extend existing server": {
 			initialHTS: hostToServer{
-				"host": models.IpvanishServer{
+				"host": models.Server{
 					Hostname: "host",
 					Country:  "country",
 					City:     "city",
@@ -71,7 +71,7 @@ func Test_hostToServer_add(t *testing.T) {
 			tcp:     false,
 			udp:     true,
 			expectedHTS: hostToServer{
-				"host": models.IpvanishServer{
+				"host": models.Server{
 					Hostname: "host",
 					Country:  "country",
 					City:     "city",
@@ -138,14 +138,14 @@ func Test_hostToServer_adaptWithIPs(t *testing.T) {
 				"A": {{1, 2, 3, 4}},
 			},
 			expectedHTS: hostToServer{
-				"A": models.IpvanishServer{
+				"A": models.Server{
 					IPs: []net.IP{{1, 2, 3, 4}},
 				},
 			},
 		},
 		"add IPs to existing server": {
 			initialHTS: hostToServer{
-				"A": models.IpvanishServer{
+				"A": models.Server{
 					Country: "country",
 				},
 			},
@@ -153,7 +153,7 @@ func Test_hostToServer_adaptWithIPs(t *testing.T) {
 				"A": {{1, 2, 3, 4}},
 			},
 			expectedHTS: hostToServer{
-				"A": models.IpvanishServer{
+				"A": models.Server{
 					Country: "country",
 					IPs:     []net.IP{{1, 2, 3, 4}},
 				},
@@ -161,7 +161,7 @@ func Test_hostToServer_adaptWithIPs(t *testing.T) {
 		},
 		"remove server without IP": {
 			initialHTS: hostToServer{
-				"A": models.IpvanishServer{
+				"A": models.Server{
 					Country: "country",
 				},
 			},
@@ -183,18 +183,18 @@ func Test_hostToServer_toServersSlice(t *testing.T) {
 	t.Parallel()
 	testCases := map[string]struct {
 		hts     hostToServer
-		servers []models.IpvanishServer
+		servers []models.Server
 	}{
 		"empty host to server": {
 			hts:     hostToServer{},
-			servers: []models.IpvanishServer{},
+			servers: []models.Server{},
 		},
 		"multiple servers": {
 			hts: hostToServer{
 				"A": {Country: "A"},
 				"B": {Country: "B"},
 			},
-			servers: []models.IpvanishServer{
+			servers: []models.Server{
 				{Country: "A"},
 				{Country: "B"},
 			},

internal/updater/providers/ipvanish/servers.go

@@ -18,7 +18,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.IpvanishServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	const url = "https://www.ipvanish.com/software/configs/configs.zip"
 	contents, err := unzipper.FetchAndExtract(ctx, url)
 	if err != nil {

internal/updater/providers/ipvanish/servers_test.go

@@ -34,7 +34,7 @@ func Test_GetServers(t *testing.T) {
 		resolveErr      error
 
 		// Output
-		servers  []models.IpvanishServer
+		servers  []models.Server
 		warnings []string
 		err      error
 	}{
@@ -109,7 +109,7 @@ func Test_GetServers(t *testing.T) {
 				"hostb": {{3, 3, 3, 3}, {4, 4, 4, 4}},
 			},
 			resolveWarnings: []string{"resolve warning"},
-			servers: []models.IpvanishServer{
+			servers: []models.Server{
 				{Country: "Canada", City: "City A", Hostname: "hosta", UDP: true, IPs: []net.IP{{1, 1, 1, 1}, {2, 2, 2, 2}}},
 				{Country: "Luxembourg", City: "City B", Hostname: "hostb", UDP: true, IPs: []net.IP{{3, 3, 3, 3}, {4, 4, 4, 4}}},
 			},

internal/updater/providers/ipvanish/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.IpvanishServer) {
+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 {

internal/updater/providers/ipvanish/sort_test.go

@@ -10,18 +10,18 @@ import (
 func Test_sortServers(t *testing.T) {
 	t.Parallel()
 	testCases := map[string]struct {
-		initialServers []models.IpvanishServer
-		sortedServers  []models.IpvanishServer
+		initialServers []models.Server
+		sortedServers  []models.Server
 	}{
 		"no server": {},
 		"sorted servers": {
-			initialServers: []models.IpvanishServer{
+			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.IpvanishServer{
+			sortedServers: []models.Server{
 				{Country: "A", City: "A", Hostname: "A"},
 				{Country: "A", City: "A", Hostname: "B"},
 				{Country: "A", City: "B", Hostname: "A"},

internal/updater/providers/ivpn/servers.go

@@ -19,7 +19,7 @@ var (
 
 func GetServers(ctx context.Context, client *http.Client,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.IvpnServer, warnings []string, err error) {
+	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)
@@ -49,7 +49,7 @@ func GetServers(ctx context.Context, client *http.Client,
 		return nil, warnings, err
 	}
 
-	servers = make([]models.IvpnServer, 0, len(hosts))
+	servers = make([]models.Server, 0, len(hosts))
 	for _, serverData := range data.Servers {
 		vpnType := constants.OpenVPN
 		hostname := serverData.Hostnames.OpenVPN
@@ -62,7 +62,7 @@ func GetServers(ctx context.Context, client *http.Client,
 			wgPubKey = serverData.WgPubKey
 		}
 
-		server := models.IvpnServer{
+		server := models.Server{
 			VPN:      vpnType,
 			Country:  serverData.Country,
 			City:     serverData.City,

internal/updater/providers/ivpn/servers_test.go

@@ -38,7 +38,7 @@ func Test_GetServers(t *testing.T) {
 		resolveErr      error
 
 		// Output
-		servers  []models.IvpnServer
+		servers  []models.Server
 		warnings []string
 		err      error
 	}{
@@ -84,7 +84,7 @@ func Test_GetServers(t *testing.T) {
 				"hostc": {{5, 5, 5, 5}, {6, 6, 6, 6}},
 			},
 			resolveWarnings: []string{"resolve warning"},
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Country: "Country1",
 					City: "City A", Hostname: "hosta", TCP: true, UDP: true,
 					IPs: []net.IP{{1, 1, 1, 1}, {2, 2, 2, 2}}},

internal/updater/providers/ivpn/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.IvpnServer) {
+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 {

internal/updater/providers/ivpn/sort_test.go

@@ -10,18 +10,18 @@ import (
 func Test_sortServers(t *testing.T) {
 	t.Parallel()
 	testCases := map[string]struct {
-		initialServers []models.IvpnServer
-		sortedServers  []models.IvpnServer
+		initialServers []models.Server
+		sortedServers  []models.Server
 	}{
 		"no server": {},
 		"sorted servers": {
-			initialServers: []models.IvpnServer{
+			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.IvpnServer{
+			sortedServers: []models.Server{
 				{Country: "A", City: "A", Hostname: "A"},
 				{Country: "A", City: "A", Hostname: "B"},
 				{Country: "A", City: "B", Hostname: "A"},

internal/updater/providers/mullvad/hosttoserver.go

@@ -10,7 +10,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.MullvadServer
+type hostToServer map[string]models.Server
 
 var (
 	ErrNoIP                = errors.New("no IP address for VPN server")
@@ -73,8 +73,8 @@ func (hts hostToServer) add(data serverData) (err error) {
 	return nil
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.MullvadServer) {
-	servers = make([]models.MullvadServer, 0, len(hts))
+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)

internal/updater/providers/mullvad/servers.go

@@ -14,7 +14,7 @@ import (
 var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, client *http.Client, minServers int) (
-	servers []models.MullvadServer, err error) {
+	servers []models.Server, err error) {
 	data, err := fetchAPI(ctx, client)
 	if err != nil {
 		return nil, err

internal/updater/providers/mullvad/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.MullvadServer) {
+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 {

internal/updater/providers/nordvpn/servers.go

@@ -19,13 +19,13 @@ var (
 )
 
 func GetServers(ctx context.Context, client *http.Client, minServers int) (
-	servers []models.NordvpnServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	data, err := fetchAPI(ctx, client)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	servers = make([]models.NordvpnServer, 0, len(data))
+	servers = make([]models.Server, 0, len(data))
 
 	for _, jsonServer := range data {
 		if !jsonServer.Features.TCP && !jsonServer.Features.UDP {
@@ -44,7 +44,7 @@ func GetServers(ctx context.Context, client *http.Client, minServers int) (
 			return nil, nil, err
 		}
 
-		server := models.NordvpnServer{
+		server := models.Server{
 			Region:   jsonServer.Country,
 			Hostname: jsonServer.Domain,
 			Number:   number,

internal/updater/providers/nordvpn/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.NordvpnServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Region == servers[j].Region {
 			return servers[i].Number < servers[j].Number

internal/updater/providers/perfectprivacy/citytoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type cityToServer map[string]models.PerfectprivacyServer
+type cityToServer map[string]models.Server
 
 func (cts cityToServer) add(city string, ips []net.IP) {
 	server, ok := cts[city]
@@ -36,8 +36,8 @@ func (cts cityToServer) add(city string, ips []net.IP) {
 	cts[city] = server
 }
 
-func (cts cityToServer) toServersSlice() (servers []models.PerfectprivacyServer) {
-	servers = make([]models.PerfectprivacyServer, 0, len(cts))
+func (cts cityToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(cts))
 	for _, server := range cts {
 		servers = append(servers, server)
 	}

internal/updater/providers/perfectprivacy/servers.go

@@ -15,7 +15,7 @@ import (
 var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper, minServers int) (
-	servers []models.PerfectprivacyServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	zipURL := url.URL{
 		Scheme: "https",
 		Host:   "www.perfect-privacy.com",

internal/updater/providers/perfectprivacy/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.PerfectprivacyServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		return servers[i].City < servers[j].City
 	})

internal/updater/providers/pia/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type nameToServer map[string]models.PIAServer
+type nameToServer map[string]models.Server
 
 func (nts nameToServer) add(name, hostname, region string,
 	tcp, udp, portForward bool, ip net.IP) (change bool) {
@@ -46,8 +46,8 @@ func (nts nameToServer) add(name, hostname, region string,
 	return change
 }
 
-func (nts nameToServer) toServersSlice() (servers []models.PIAServer) {
-	servers = make([]models.PIAServer, 0, len(nts))
+func (nts nameToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(nts))
 	for _, server := range nts {
 		servers = append(servers, server)
 	}

internal/updater/providers/pia/servers.go

@@ -15,7 +15,7 @@ import (
 var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, client *http.Client, minServers int) (
-	servers []models.PIAServer, err error) {
+	servers []models.Server, err error) {
 	nts := make(nameToServer)
 
 	noChangeCounter := 0

internal/updater/providers/pia/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.PIAServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Region == servers[j].Region {
 			if servers[i].Hostname == servers[j].Hostname {

internal/updater/providers/privado/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.PrivadoServer
+type hostToServer map[string]models.Server
 
 func (hts hostToServer) add(host string) {
 	server, ok := hts[host]
@@ -38,8 +38,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.PrivadoServer) {
-	servers = make([]models.PrivadoServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/privado/location.go

@@ -9,7 +9,7 @@ import (
 	"github.com/qdm12/gluetun/internal/publicip"
 )
 
-func setLocationInfo(ctx context.Context, client *http.Client, servers []models.PrivadoServer) (err error) {
+func setLocationInfo(ctx context.Context, client *http.Client, servers []models.Server) (err error) {
 	// Get public IP address information
 	ipsToGetInfo := make([]net.IP, 0, len(servers))
 	for _, server := range servers {

internal/updater/providers/privado/servers.go

@@ -19,7 +19,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	client *http.Client, presolver resolver.Parallel, minServers int) (
-	servers []models.PrivadoServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	const url = "https://privado.io/apps/ovpn_configs.zip"
 	contents, err := unzipper.FetchAndExtract(ctx, url)
 	if err != nil {

internal/updater/providers/privado/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.PrivadoServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Country == servers[j].Country {
 			if servers[i].Region == servers[j].Region {

internal/updater/providers/privatevpn/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.PrivatevpnServer
+type hostToServer map[string]models.Server
 
 // TODO check if server supports TCP and UDP.
 func (hts hostToServer) add(host, country, city string) {
@@ -41,8 +41,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.PrivatevpnServer) {
-	servers = make([]models.PrivatevpnServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/privatevpn/servers.go

@@ -19,7 +19,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.PrivatevpnServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	const url = "https://privatevpn.com/client/PrivateVPN-TUN.zip"
 	contents, err := unzipper.FetchAndExtract(ctx, url)
 	if err != nil {
@@ -32,7 +32,7 @@ func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	countryCodes := constants.CountryCodes()
 
 	hts := make(hostToServer)
-	noHostnameServers := make([]models.PrivatevpnServer, 0, 1) // there is only one for now
+	noHostnameServers := make([]models.Server, 0, 1) // there is only one for now
 
 	for fileName, content := range contents {
 		if !strings.HasSuffix(fileName, ".ovpn") {
@@ -69,7 +69,7 @@ func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 			warnings = append(warnings, warning)
 			continue
 		}
-		server := models.PrivatevpnServer{
+		server := models.Server{
 			Country: country,
 			City:    city,
 			IPs:     ips,

internal/updater/providers/privatevpn/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.PrivatevpnServer) {
+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 {

internal/updater/providers/protonvpn/iptoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type ipToServer map[string]models.ProtonvpnServer
+type ipToServer map[string]models.Server
 
 func (its ipToServer) add(country, region, city, name, hostname string,
 	entryIP net.IP) {
@@ -17,7 +17,7 @@ func (its ipToServer) add(country, region, city, name, hostname string,
 		server.Country = country
 		server.Region = region
 		server.City = city
-		server.Name = name
+		server.ServerName = name
 		server.Hostname = hostname
 		server.IPs = []net.IP{entryIP}
 	} else {
@@ -27,8 +27,8 @@ func (its ipToServer) add(country, region, city, name, hostname string,
 	its[key] = server
 }
 
-func (its ipToServer) toServersSlice() (servers []models.ProtonvpnServer) {
-	servers = make([]models.ProtonvpnServer, 0, len(its))
+func (its ipToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(its))
 	for _, server := range its {
 		servers = append(servers, server)
 	}

internal/updater/providers/protonvpn/servers.go

@@ -15,7 +15,7 @@ import (
 var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, client *http.Client, minServers int) (
-	servers []models.ProtonvpnServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	data, err := fetchAPI(ctx, client)
 	if err != nil {
 		return nil, nil, err

internal/updater/providers/protonvpn/sort.go

@@ -6,16 +6,16 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.ProtonvpnServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		a, b := servers[i], servers[j]
 		if a.Country == b.Country { //nolint:nestif
 			if a.Region == b.Region {
 				if a.City == b.City {
-					if a.Name == b.Name {
+					if a.ServerName == b.ServerName {
 						return a.Hostname < b.Hostname
 					}
-					return a.Name < b.Name
+					return a.ServerName < b.ServerName
 				}
 				return a.City < b.City
 			}

internal/updater/providers/purevpn/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.PurevpnServer
+type hostToServer map[string]models.Server
 
 func (hts hostToServer) add(host string, tcp, udp bool) {
 	server, ok := hts[host]
@@ -43,8 +43,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.PurevpnServer) {
-	servers = make([]models.PurevpnServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/purevpn/servers.go

@@ -21,7 +21,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, client *http.Client,
 	unzipper unzip.Unzipper, presolver resolver.Parallel, minServers int) (
-	servers []models.PurevpnServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	const url = "https://d32d3g1fvkpl8y.cloudfront.net/heartbleed/windows/New+OVPN+Files.zip"
 	contents, err := unzipper.FetchAndExtract(ctx, url)
 	if err != nil {

internal/updater/providers/purevpn/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.PurevpnServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Country == servers[j].Country {
 			if servers[i].Region == servers[j].Region {

internal/updater/providers/surfshark/api_test.go

@@ -37,7 +37,7 @@ func Test_addServersFromAPI(t *testing.T) {
 				{"connectionName":"host1","region":"region1","country":"country1","location":"location1"},
 				{"connectionName":"host2","region":"region2","country":"country1","location":"location2"}
 			]`)),
-			expected: map[string]models.SurfsharkServer{
+			expected: map[string]models.Server{
 				"existinghost": {Hostname: "existinghost"},
 				"host1": {
 					Region:   "region1",

internal/updater/providers/surfshark/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.SurfsharkServer
+type hostToServer map[string]models.Server
 
 func (hts hostToServer) add(host, region, country, city, retroLoc string, tcp, udp bool) {
 	server, ok := hts[host]
@@ -47,8 +47,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.SurfsharkServer) {
-	servers = make([]models.SurfsharkServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/surfshark/servers.go

@@ -19,7 +19,7 @@ var (
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	client *http.Client, presolver resolver.Parallel, minServers int) (
-	servers []models.SurfsharkServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	hts := make(hostToServer)
 
 	err = addServersFromAPI(ctx, client, hts)

internal/updater/providers/surfshark/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.SurfsharkServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Region == servers[j].Region {
 			if servers[i].Country == servers[j].Country {

internal/updater/providers/surfshark/sort_test.go

@@ -10,19 +10,19 @@ import (
 func Test_sortServers(t *testing.T) {
 	t.Parallel()
 	testCases := map[string]struct {
-		initialServers []models.SurfsharkServer
-		sortedServers  []models.SurfsharkServer
+		initialServers []models.Server
+		sortedServers  []models.Server
 	}{
 		"no server": {},
 		"sorted servers": {
-			initialServers: []models.SurfsharkServer{
+			initialServers: []models.Server{
 				{Region: "Z", Country: "B", City: "A", Hostname: "A"},
 				{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.SurfsharkServer{
+			sortedServers: []models.Server{
 				{Country: "A", City: "A", Hostname: "A"},
 				{Country: "A", City: "A", Hostname: "B"},
 				{Country: "A", City: "B", Hostname: "A"},

internal/updater/providers/torguard/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.TorguardServer
+type hostToServer map[string]models.Server
 
 func (hts hostToServer) add(host, country, city string,
 	tcp, udp bool, ips []net.IP) {
@@ -50,8 +50,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.TorguardServer) {
-	servers = make([]models.TorguardServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/torguard/servers.go

@@ -18,7 +18,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.TorguardServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	const tcpURL = "https://torguard.net/downloads/OpenVPN-TCP-Linux.zip"
 	tcpContents, err := unzipper.FetchAndExtract(ctx, tcpURL)
 	if err != nil {

internal/updater/providers/torguard/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.TorguardServer) {
+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 {

internal/updater/providers/vpnunlimited/constants.go

@@ -8,7 +8,7 @@ import (
 )
 
 func getHostToServer() (hts hostToServer, warnings []string) {
-	shortHTS := map[string]models.VPNUnlimitedServer{
+	shortHTS := map[string]models.Server{
 		"ae": {},
 		"ar": {},
 		"at": {},

internal/updater/providers/vpnunlimited/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.VPNUnlimitedServer
+type hostToServer map[string]models.Server
 
 func (hts hostToServer) toHostsSlice() (hosts []string) {
 	hosts = make([]string, 0, len(hts))
@@ -29,8 +29,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.VPNUnlimitedServer) {
-	servers = make([]models.VPNUnlimitedServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/vpnunlimited/servers.go

@@ -16,7 +16,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.VPNUnlimitedServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	// Hardcoded data from a user provided ZIP file since it's behind a login wall
 	hts, warnings := getHostToServer()
 

internal/updater/providers/vpnunlimited/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.VPNUnlimitedServer) {
+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 {

internal/updater/providers/vyprvpn/hosttoserver.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.VyprvpnServer
+type hostToServer map[string]models.Server
 
 func (hts hostToServer) add(host, region string, tcp, udp bool) {
 	server, ok := hts[host]
@@ -44,8 +44,8 @@ func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]net.IP) {
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.VyprvpnServer) {
-	servers = make([]models.VyprvpnServer, 0, len(hts))
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
 	for _, server := range hts {
 		servers = append(servers, server)
 	}

internal/updater/providers/vyprvpn/servers.go

@@ -18,7 +18,7 @@ var ErrNotEnoughServers = errors.New("not enough servers found")
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 	presolver resolver.Parallel, minServers int) (
-	servers []models.VyprvpnServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	const url = "https://support.vyprvpn.com/hc/article_attachments/360052617332/Vypr_OpenVPN_20200320.zip"
 	contents, err := unzipper.FetchAndExtract(ctx, url)
 	if err != nil {

internal/updater/providers/vyprvpn/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.VyprvpnServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		return servers[i].Region < servers[j].Region
 	})

internal/updater/providers/wevpn/servers.go

@@ -18,9 +18,9 @@ var (
 )
 
 func GetServers(ctx context.Context, presolver resolver.Parallel, minServers int) (
-	servers []models.WevpnServer, warnings []string, err error) {
+	servers []models.Server, warnings []string, err error) {
 	cities := getAvailableCities()
-	servers = make([]models.WevpnServer, 0, len(cities))
+	servers = make([]models.Server, 0, len(cities))
 	hostnames := make([]string, len(cities))
 	hostnameToCity := make(map[string]string, len(cities))
 
@@ -43,7 +43,7 @@ func GetServers(ctx context.Context, presolver resolver.Parallel, minServers int
 
 	for hostname, ips := range hostnameToIPs {
 		city := hostnameToCity[hostname]
-		server := models.WevpnServer{
+		server := models.Server{
 			City:     city,
 			Hostname: hostname,
 			UDP:      true,

internal/updater/providers/wevpn/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.WevpnServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].City == servers[j].City {
 			return servers[i].Hostname < servers[j].Hostname

internal/updater/providers/wevpn/sort_test.go

@@ -10,18 +10,18 @@ import (
 func Test_sortServers(t *testing.T) {
 	t.Parallel()
 	testCases := map[string]struct {
-		initialServers []models.WevpnServer
-		sortedServers  []models.WevpnServer
+		initialServers []models.Server
+		sortedServers  []models.Server
 	}{
 		"no server": {},
 		"sorted servers": {
-			initialServers: []models.WevpnServer{
+			initialServers: []models.Server{
 				{City: "A", Hostname: "A"},
 				{City: "A", Hostname: "B"},
 				{City: "A", Hostname: "A"},
 				{City: "B", Hostname: "A"},
 			},
-			sortedServers: []models.WevpnServer{
+			sortedServers: []models.Server{
 				{City: "A", Hostname: "A"},
 				{City: "A", Hostname: "A"},
 				{City: "A", Hostname: "B"},

internal/updater/providers/windscribe/servers.go

@@ -19,7 +19,7 @@ var (
 )
 
 func GetServers(ctx context.Context, client *http.Client, minServers int) (
-	servers []models.WindscribeServer, err error) {
+	servers []models.Server, err error) {
 	data, err := fetchAPI(ctx, client)
 	if err != nil {
 		return nil, err
@@ -39,7 +39,7 @@ func GetServers(ctx context.Context, client *http.Client, minServers int) (
 				if node.IP2 != nil {
 					ips = append(ips, node.IP2)
 				}
-				server := models.WindscribeServer{
+				server := models.Server{
 					VPN:      constants.OpenVPN,
 					Region:   region,
 					City:     city,

internal/updater/providers/windscribe/sort.go

@@ -6,7 +6,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-func sortServers(servers []models.WindscribeServer) {
+func sortServers(servers []models.Server) {
 	sort.Slice(servers, func(i, j int) bool {
 		if servers[i].Region == servers[j].Region {
 			if servers[i].City == servers[j].City {