admin/gluetun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Maint: Remove CYBERGHOST_GROUP (change)

Browse Source 
- It does not make any sense with newer server data
- It was to be deprecated anyway
This commit is contained in:
Quentin McGaw (desktop)
2021-09-23 13:54:24 +00:00
parent 625de1c834
commit f9aadeef1c
17 changed files with 1910 additions and 1846 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Dockerfile
View File

@@ -106,7 +106,6 @@ ENV VPNSP=pia \
PORT_FORWARDING=off \
PORT_FORWARDING_STATUS_FILE="/tmp/gluetun/forwarded_port" \
# # Cyberghost only:
CYBERGHOST_GROUP="Premium UDP Europe" \
OPENVPN_CLIENTCRT_SECRETFILE=/run/secrets/openvpn_clientcrt \
OPENVPN_CLIENTKEY_SECRETFILE=/run/secrets/openvpn_clientkey \
# # Nordvpn only:

6
internal/configuration/cyberghost.go
View File

@@ -16,12 +16,6 @@ func (settings *Provider) readCyberghost(r reader) (err error) {
return err
}
settings.ServerSelection.Groups, err = r.env.CSVInside("CYBERGHOST_GROUP",
constants.CyberghostGroupChoices(servers))
if err != nil {
return fmt.Errorf("environment variable CYBERGHOST_GROUP: %w", err)
}
settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY",
constants.CyberghostCountryChoices(servers),
params.RetroKeys([]string{"REGION"}, r.onRetroActive))

2
internal/configuration/provider_test.go
View File

@@ -25,13 +25,11 @@ func Test_Provider_lines(t *testing.T) {
Name: constants.Cyberghost,
ServerSelection: ServerSelection{
VPN: constants.OpenVPN,
Groups: []string{"group"},
Countries: []string{"a", "El country"},
},
},
lines: []string{
"|--Cyberghost settings:",
" |--Server groups: group",
" |--Countries: a, El country",
" |--OpenVPN selection:",
" |--Protocol: udp",

7
internal/configuration/selection.go
View File

@@ -15,9 +15,6 @@ type ServerSelection struct { //nolint:maligned
// Cyberghost, PIA, Protonvpn, Surfshark, Windscribe, Vyprvpn, NordVPN
Regions []string `json:"regions"`
// Cyberghost
Groups []string `json:"groups"`
// Fastestvpn, HideMyAss, IPVanish, IVPN, Mullvad, PrivateVPN, Protonvpn, PureVPN, VPNUnlimited
Countries []string `json:"countries"`
// HideMyAss, IPVanish, IVPN, Mullvad, PrivateVPN, Protonvpn, PureVPN, VPNUnlimited, Windscribe
@@ -51,10 +48,6 @@ func (selection ServerSelection) toLines() (lines []string) {
lines = append(lines, lastIndent+"Target IP address: "+selection.TargetIP.String())
}
if len(selection.Groups) > 0 {
lines = append(lines, lastIndent+"Server groups: "+commaJoin(selection.Groups))
}
if len(selection.Countries) > 0 {
lines = append(lines, lastIndent+"Countries: "+commaJoin(selection.Countries))
}

19
internal/constants/cyberghost.go
View File

@@ -1,8 +1,6 @@
package constants
import (
"sort"
"github.com/qdm12/gluetun/internal/models"
)
@@ -19,23 +17,6 @@ func CyberghostCountryChoices(servers []models.CyberghostServer) (choices []stri
return makeUnique(choices)
}
func CyberghostGroupChoices(servers []models.CyberghostServer) (choices []string) {
uniqueChoices := map[string]struct{}{}
for _, server := range servers {
uniqueChoices[server.Group] = struct{}{}
}
choices = make([]string, 0, len(uniqueChoices))
for choice := range uniqueChoices {
choices = append(choices, choice)
}
sortable := sort.StringSlice(choices)
sortable.Sort()
return sortable
}
func CyberghostHostnameChoices(servers []models.CyberghostServer) (choices []string) {
choices = make([]string, len(servers))
for i := range servers {

30
internal/constants/cyberghost_test.go
View File

@@ -1,30 +0,0 @@
package constants
import (
"testing"
"github.com/golang/mock/gomock"
"github.com/qdm12/gluetun/internal/storage"
"github.com/qdm12/golibs/logging/mock_logging"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func Test_CyberghostGroupChoices(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
logger := mock_logging.NewMockLogger(ctrl)
logger.EXPECT().Info(gomock.Any())
storage, err := storage.New(logger, "")
require.NoError(t, err)
servers := storage.GetServers()
expected := []string{"NoSpy TCP Europe", "NoSpy UDP Europe",
"Premium TCP Europe", "Premium UDP Europe"}
choices := CyberghostGroupChoices(servers.GetCyberghost())
assert.Equal(t, expected, choices)
}

5
internal/models/markdown.go
View File

@@ -18,7 +18,7 @@ func markdownTableHeading(legendFields ...string) (markdown string) {
}
func (s *CyberghostServers) ToMarkdown() (markdown string) {
markdown = markdownTableHeading("Country", "Group", "Hostname")
markdown = markdownTableHeading("Country", "Hostname", "TCP", "UDP")
for _, server := range s.Servers {
markdown += server.ToMarkdown() + "\n"
}
@@ -26,7 +26,8 @@ func (s *CyberghostServers) ToMarkdown() (markdown string) {
}
func (s CyberghostServer) ToMarkdown() (markdown string) {
return fmt.Sprintf("| %s | %s | `%s` |", s.Country, s.Group, s.Hostname)
return fmt.Sprintf("| %s | `%s` | %s | %s |", s.Country, s.Hostname,
boolToMarkdown(s.TCP), boolToMarkdown(s.UDP))
}
func (s *FastestvpnServers) ToMarkdown() (markdown string) {

12
internal/models/markdown_test.go
View File

@@ -11,16 +11,16 @@ func Test_CyberghostServers_ToMarkdown(t *testing.T) {
servers := CyberghostServers{
Servers: []CyberghostServer{
{Country: "a", Group: "A", Hostname: "xa"},
{Country: "b", Group: "A", Hostname: "xb"},
{Country: "a", UDP: true, Hostname: "xa"},
{Country: "b", TCP: true, Hostname: "xb"},
},
}
markdown := servers.ToMarkdown()
const expected = "| Country | Group | Hostname |\n" +
"| --- | --- | --- |\n" +
"| a | A | `xa` |\n" +
"| b | A | `xb` |\n"
const expected = "| Country | Hostname | TCP | UDP |\n" +
"| --- | --- | --- | --- |\n" +
"| a | `xa` | ❎ | ✅ |\n" +
"| b | `xb` | ✅ | ❎ |\n"
assert.Equal(t, expected, markdown)
}

3
internal/models/server.go
View File

@@ -6,8 +6,9 @@ import (
type CyberghostServer struct {
Country string `json:"country"`
Group string `json:"group"`
Hostname string `json:"hostname"`
TCP bool `json:"tcp"`
UDP bool `json:"udp"`
IPs []net.IP `json:"ips"`
}

70
internal/provider/cyberghost/filter.go
View File

@@ -2,11 +2,8 @@ package cyberghost
import (
"errors"
"fmt"
"strings"
"github.com/qdm12/gluetun/internal/configuration"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
@@ -15,27 +12,10 @@ var ErrGroupMismatchesProtocol = errors.New("server group does not match protoco
func (c *Cyberghost) filterServers(selection configuration.ServerSelection) (
servers []models.CyberghostServer, err error) {
if len(selection.Groups) == 0 {
if selection.OpenVPN.TCP {
selection.Groups = tcpGroupChoices(c.servers)
} else {
selection.Groups = udpGroupChoices(c.servers)
}
}
// Check each group match the protocol
groupsCheckFn := groupsAreAllUDP
if selection.OpenVPN.TCP {
groupsCheckFn = groupsAreAllTCP
}
if err := groupsCheckFn(selection.Groups); err != nil {
return nil, err
}
for _, server := range c.servers {
switch {
case
utils.FilterByPossibilities(server.Group, selection.Groups),
utils.FilterByProtocol(selection, server.TCP, server.UDP),
utils.FilterByPossibilities(server.Country, selection.Countries),
utils.FilterByPossibilities(server.Hostname, selection.Hostnames):
default:
@@ -49,51 +29,3 @@ func (c *Cyberghost) filterServers(selection configuration.ServerSelection) (
return servers, nil
}
func tcpGroupChoices(servers []models.CyberghostServer) (choices []string) {
const tcp = true
return groupsForTCP(servers, tcp)
}
func udpGroupChoices(servers []models.CyberghostServer) (choices []string) {
const tcp = false
return groupsForTCP(servers, tcp)
}
func groupsForTCP(servers []models.CyberghostServer, tcp bool) (choices []string) {
allGroups := constants.CyberghostGroupChoices(servers)
choices = make([]string, 0, len(allGroups))
for _, group := range allGroups {
switch {
case tcp && groupIsTCP(group):
choices = append(choices, group)
case !tcp && !groupIsTCP(group):
choices = append(choices, group)
}
}
return choices
}
func groupIsTCP(group string) bool {
return strings.Contains(strings.ToLower(group), "tcp")
}
func groupsAreAllTCP(groups []string) error {
for _, group := range groups {
if !groupIsTCP(group) {
return fmt.Errorf("%w: group %s for protocol TCP",
ErrGroupMismatchesProtocol, group)
}
}
return nil
}
func groupsAreAllUDP(groups []string) error {
for _, group := range groups {
if groupIsTCP(group) {
return fmt.Errorf("%w: group %s for protocol UDP",
ErrGroupMismatchesProtocol, group)
}
}
return nil
}

126
internal/provider/cyberghost/filter_test.go
View File

@@ -25,22 +25,22 @@ func Test_Cyberghost_filterServers(t *testing.T) {
},
"servers without filter defaults to UDP": {
servers: []models.CyberghostServer{
{Country: "a", Group: "Premium TCP Asia"},
{Country: "b", Group: "Premium TCP Europe"},
{Country: "c", Group: "Premium UDP Asia"},
{Country: "d", Group: "Premium UDP Europe"},
{Country: "a", TCP: true},
{Country: "b", TCP: true},
{Country: "c", UDP: true},
{Country: "d", UDP: true},
},
filteredServers: []models.CyberghostServer{
{Country: "c", Group: "Premium UDP Asia"},
{Country: "d", Group: "Premium UDP Europe"},
{Country: "c", UDP: true},
{Country: "d", UDP: true},
},
},
"servers with TCP selection": {
servers: []models.CyberghostServer{
{Country: "a", Group: "Premium TCP Asia"},
{Country: "b", Group: "Premium TCP Europe"},
{Country: "c", Group: "Premium UDP Asia"},
{Country: "d", Group: "Premium UDP Europe"},
{Country: "a", TCP: true},
{Country: "b", TCP: true},
{Country: "c", UDP: true},
{Country: "d", UDP: true},
},
selection: configuration.ServerSelection{
OpenVPN: configuration.OpenVPNSelection{
@@ -48,79 +48,37 @@ func Test_Cyberghost_filterServers(t *testing.T) {
},
},
filteredServers: []models.CyberghostServer{
{Country: "a", Group: "Premium TCP Asia"},
{Country: "b", Group: "Premium TCP Europe"},
{Country: "a", TCP: true},
{Country: "b", TCP: true},
},
},
"servers with regions filter": {
servers: []models.CyberghostServer{
{Country: "a", Group: "Premium UDP Asia"},
{Country: "b", Group: "Premium UDP Asia"},
{Country: "c", Group: "Premium UDP Asia"},
{Country: "d", Group: "Premium UDP Asia"},
{Country: "a", UDP: true},
{Country: "b", UDP: true},
{Country: "c", UDP: true},
{Country: "d", UDP: true},
},
selection: configuration.ServerSelection{
Countries: []string{"a", "c"},
},
filteredServers: []models.CyberghostServer{
{Country: "a", Group: "Premium UDP Asia"},
{Country: "c", Group: "Premium UDP Asia"},
},
},
"servers with group filter": {
servers: []models.CyberghostServer{
{Country: "a", Group: "Premium UDP Europe"},
{Country: "b", Group: "Premium UDP Europe"},
{Country: "c", Group: "Premium TCP Europe"},
{Country: "d", Group: "Premium TCP Europe"},
},
selection: configuration.ServerSelection{
Groups: []string{"Premium UDP Europe"},
},
filteredServers: []models.CyberghostServer{
{Country: "a", Group: "Premium UDP Europe"},
{Country: "b", Group: "Premium UDP Europe"},
},
},
"servers with bad group filter": {
servers: []models.CyberghostServer{
{Country: "a", Group: "Premium TCP Europe"},
{Country: "b", Group: "Premium TCP Europe"},
{Country: "c", Group: "Premium UDP Europe"},
{Country: "d", Group: "Premium UDP Europe"},
},
selection: configuration.ServerSelection{
Groups: []string{"Premium TCP Europe"},
},
err: errors.New("server group does not match protocol: group Premium TCP Europe for protocol UDP"),
},
"servers with regions and group filter": {
servers: []models.CyberghostServer{
{Country: "a", Group: "Premium UDP Europe"},
{Country: "b", Group: "Premium TCP Europe"},
{Country: "c", Group: "Premium UDP Asia"},
{Country: "d", Group: "Premium TCP Asia"},
},
selection: configuration.ServerSelection{
Countries: []string{"a", "c"},
Groups: []string{"Premium UDP Europe"},
},
filteredServers: []models.CyberghostServer{
{Country: "a", Group: "Premium UDP Europe"},
{Country: "a", UDP: true},
{Country: "c", UDP: true},
},
},
"servers with hostnames filter": {
servers: []models.CyberghostServer{
{Hostname: "a", Group: "Premium UDP Asia"},
{Hostname: "b", Group: "Premium UDP Asia"},
{Hostname: "c", Group: "Premium UDP Asia"},
{Hostname: "a", UDP: true},
{Hostname: "b", UDP: true},
{Hostname: "c", UDP: true},
},
selection: configuration.ServerSelection{
Hostnames: []string{"a", "c"},
},
filteredServers: []models.CyberghostServer{
{Hostname: "a", Group: "Premium UDP Asia"},
{Hostname: "c", Group: "Premium UDP Asia"},
{Hostname: "a", UDP: true},
{Hostname: "c", UDP: true},
},
},
}
@@ -142,41 +100,3 @@ func Test_Cyberghost_filterServers(t *testing.T) {
})
}
}
func Test_tcpGroupChoices(t *testing.T) {
t.Parallel()
servers := []models.CyberghostServer{
{Group: "Premium TCP Asia"},
{Group: "Premium TCP Europe"},
{Group: "Premium TCP USA"},
{Group: "Premium UDP Asia"},
{Group: "Premium UDP Europe"},
{Group: "Premium UDP USA"},
}
expected := []string{
"Premium TCP Asia", "Premium TCP Europe", "Premium TCP USA",
}
choices := tcpGroupChoices(servers)
assert.Equal(t, expected, choices)
}
func Test_udpGroupChoices(t *testing.T) {
t.Parallel()
servers := []models.CyberghostServer{
{Group: "Premium TCP Asia"},
{Group: "Premium TCP Europe"},
{Group: "Premium TCP USA"},
{Group: "Premium UDP Asia"},
{Group: "Premium UDP Europe"},
{Group: "Premium UDP USA"},
}
expected := []string{
"Premium UDP Asia", "Premium UDP Europe", "Premium UDP USA",
}
choices := udpGroupChoices(servers)
assert.Equal(t, expected, choices)
}

10
internal/provider/utils/formatting.go
View File

@@ -27,16 +27,6 @@ func NoServerFoundError(selection configuration.ServerSelection) (err error) {
}
messageParts = append(messageParts, "protocol "+protocol)
switch len(selection.Groups) {
case 0:
case 1:
part := "group " + selection.Groups[0]
messageParts = append(messageParts, part)
default:
part := "groups " + commaJoin(selection.Groups)
messageParts = append(messageParts, part)
}
switch len(selection.Countries) {
case 0:
case 1:

2
internal/storage/hardcoded_test.go
View File

@@ -51,7 +51,7 @@ func Test_versions(t *testing.T) {
"Cyberghost": {
model: models.CyberghostServer{},
version: allServers.Cyberghost.Version,
digest: "c2f6f43b",
digest: "9ce64729",
},
"Fastestvpn": {
model: models.FastestvpnServer{},

3429
internal/storage/servers.json
View File

File diff suppressed because it is too large Load Diff

20
internal/updater/providers/cyberghost/constants.go
View File

@@ -1,15 +1,17 @@
package cyberghost
func getGroups() map[string]string {
import "github.com/qdm12/gluetun/internal/constants"
func getGroupIDToProtocol() map[string]string {
return map[string]string{
"87-1": "Premium UDP Europe",
"94-1": "Premium UDP USA",
"95-1": "Premium UDP Asia",
"87-8": "NoSpy UDP Europe",
"97-1": "Premium TCP Europe",
"93-1": "Premium TCP USA",
"96-1": "Premium TCP Asia",
"97-8": "NoSpy TCP Europe",
"87-1": constants.UDP, // Premium UDP Europe
"94-1": constants.UDP, // Premium UDP USA
"95-1": constants.UDP, // Premium UDP Asia
"87-8": constants.UDP, // NoSpy UDP Europe
"97-1": constants.TCP, // Premium TCP Europe
"93-1": constants.TCP, // Premium TCP USA
"96-1": constants.TCP, // Premium TCP Asia
"97-8": constants.TCP, // NoSpy TCP Europe
}
}

9
internal/updater/providers/cyberghost/hosttoserver.go
View File

@@ -10,24 +10,25 @@ import (
type hostToServer map[string]models.CyberghostServer
func getPossibleServers() (possibleServers hostToServer) {
groups := getGroups()
groupIDToProtocol := getGroupIDToProtocol()
cyberghostCountryCodes := getSubdomainToRegion()
allCountryCodes := constants.CountryCodes()
possibleCountryCodes := mergeCountryCodes(cyberghostCountryCodes, allCountryCodes)
n := len(groups) * len(possibleCountryCodes)
n := len(groupIDToProtocol) * len(possibleCountryCodes)
possibleServers = make(hostToServer, n) // key is the host
for groupID, groupName := range groups {
for groupID, protocol := range groupIDToProtocol {
for countryCode, country := range possibleCountryCodes {
const domain = "cg-dialup.net"
possibleHost := groupID + "-" + countryCode + "." + domain
possibleServer := models.CyberghostServer{
Hostname: possibleHost,
Country: country,
Group: groupName,
TCP: protocol == constants.TCP,
UDP: protocol == constants.UDP,
}
possibleServers[possibleHost] = possibleServer
}

5
internal/updater/providers/cyberghost/sort.go
View File

@@ -9,10 +9,7 @@ import (
func sortServers(servers []models.CyberghostServer) {
sort.Slice(servers, func(i, j int) bool {
if servers[i].Country == servers[j].Country {
if servers[i].Group == servers[j].Group {
return servers[i].Hostname < servers[j].Hostname
}
return servers[i].Group < servers[j].Group
return servers[i].Hostname < servers[j].Hostname
}
return servers[i].Country < servers[j].Country
})