Feature: Protonvpn support (#437 clone on #434)

internal/configuration/openvpn.go

@@ -62,7 +62,7 @@ var (
 func (settings *OpenVPN) read(r reader) (err error) {
 	vpnsp, err := r.env.Inside("VPNSP", []string{
 		"cyberghost", "fastestvpn", "hidemyass", "mullvad", "nordvpn",
-		"privado", "pia", "private internet access", "privatevpn",
+		"privado", "pia", "private internet access", "privatevpn", "protonvpn",
 		"purevpn", "surfshark", "torguard", "vyprvpn", "windscribe"},
 		params.Default("private internet access"))
 	if err != nil {
@@ -141,6 +141,8 @@ func (settings *OpenVPN) read(r reader) (err error) {
 		readProvider = settings.Provider.readPrivateInternetAccess
 	case constants.Privatevpn:
 		readProvider = settings.Provider.readPrivatevpn
+	case constants.Protonvpn:
+		readProvider = settings.Provider.readProtonvpn
 	case constants.Purevpn:
 		readProvider = settings.Provider.readPurevpn
 	case constants.Surfshark:

internal/configuration/openvpn_test.go

@@ -16,10 +16,43 @@ func Test_OpenVPN_JSON(t *testing.T) {
 			Name: "name",
 		},
 	}
-	data, err := json.Marshal(in)
+	data, err := json.MarshalIndent(in, "", "  ")
 	require.NoError(t, err)
-	//nolint:lll
-	assert.Equal(t, `{"user":"","password":"","verbosity":0,"mssfix":0,"run_as_root":true,"cipher":"","auth":"","provider":{"name":"name","server_selection":{"network_protocol":"","regions":null,"group":"","countries":null,"cities":null,"hostnames":null,"isps":null,"owned":false,"custom_port":0,"numbers":null,"encryption_preset":""},"extra_config":{"encryption_preset":"","openvpn_ipv6":false},"port_forwarding":{"enabled":false,"filepath":""}},"custom_config":""}`, string(data))
+	assert.Equal(t, `{
+  "user": "",
+  "password": "",
+  "verbosity": 0,
+  "mssfix": 0,
+  "run_as_root": true,
+  "cipher": "",
+  "auth": "",
+  "provider": {
+    "name": "name",
+    "server_selection": {
+      "network_protocol": "",
+      "regions": null,
+      "group": "",
+      "countries": null,
+      "cities": null,
+      "hostnames": null,
+      "names": null,
+      "isps": null,
+      "owned": false,
+      "custom_port": 0,
+      "numbers": null,
+      "encryption_preset": ""
+    },
+    "extra_config": {
+      "encryption_preset": "",
+      "openvpn_ipv6": false
+    },
+    "port_forwarding": {
+      "enabled": false,
+      "filepath": ""
+    }
+  },
+  "custom_config": ""
+}`, string(data))
 	var out OpenVPN
 	err = json.Unmarshal(data, &out)
 	require.NoError(t, err)

internal/configuration/protonvpn.go

@@ -0,0 +1,75 @@
+package configuration
+
+import (
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) protonvpnLines() (lines []string) {
+	if len(settings.ServerSelection.Countries) > 0 {
+		lines = append(lines, lastIndent+"Countries: "+commaJoin(settings.ServerSelection.Countries))
+	}
+
+	if len(settings.ServerSelection.Regions) > 0 {
+		lines = append(lines, lastIndent+"Regions: "+commaJoin(settings.ServerSelection.Regions))
+	}
+
+	if len(settings.ServerSelection.Cities) > 0 {
+		lines = append(lines, lastIndent+"Cities: "+commaJoin(settings.ServerSelection.Cities))
+	}
+
+	if len(settings.ServerSelection.Names) > 0 {
+		lines = append(lines, lastIndent+"Names: "+commaJoin(settings.ServerSelection.Names))
+	}
+
+	if len(settings.ServerSelection.Hostnames) > 0 {
+		lines = append(lines, lastIndent+"Hostnames: "+commaJoin(settings.ServerSelection.Hostnames))
+	}
+
+	return lines
+}
+
+func (settings *Provider) readProtonvpn(r reader) (err error) {
+	settings.Name = constants.Protonvpn
+
+	settings.ServerSelection.Protocol, err = readProtocol(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.CustomPort, err = readPortOrZero(r.env, "PORT")
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.ProtonvpnCountryChoices())
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.ProtonvpnRegionChoices())
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.ProtonvpnCityChoices())
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_NAME", constants.ProtonvpnNameChoices())
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.ProtonvpnHostnameChoices())
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/provider.go

@@ -45,6 +45,8 @@ func (settings *Provider) lines() (lines []string) {
 		providerLines = settings.privatevpnLines()
 	case "private internet access":
 		providerLines = settings.privateinternetaccessLines()
+	case "protonvpn":
+		providerLines = settings.protonvpnLines()
 	case "purevpn":
 		providerLines = settings.purevpnLines()
 	case "surfshark":

internal/configuration/provider_test.go

@@ -148,6 +148,28 @@ func Test_Provider_lines(t *testing.T) {
 				"   |--Hostnames: a, b",
 			},
 		},
+		"protonvpn": {
+			settings: Provider{
+				Name: constants.Protonvpn,
+				ServerSelection: ServerSelection{
+					Protocol:  constants.UDP,
+					Countries: []string{"a", "b"},
+					Regions:   []string{"c", "d"},
+					Cities:    []string{"e", "f"},
+					Names:     []string{"g", "h"},
+					Hostnames: []string{"i", "j"},
+				},
+			},
+			lines: []string{
+				"|--Protonvpn settings:",
+				"   |--Network protocol: udp",
+				"   |--Countries: a, b",
+				"   |--Regions: c, d",
+				"   |--Cities: e, f",
+				"   |--Names: g, h",
+				"   |--Hostnames: i, j",
+			},
+		},
 		"private internet access": {
 			settings: Provider{
 				Name: constants.PrivateInternetAccess,

internal/configuration/selection.go

@@ -9,15 +9,16 @@ type ServerSelection struct {
 	Protocol string `json:"network_protocol"`
 	TargetIP net.IP `json:"target_ip,omitempty"`
 	// TODO comments
-	// Cyberghost, PIA, Surfshark, Windscribe, Vyprvpn, NordVPN
+	// Cyberghost, PIA, Protonvpn, Surfshark, Windscribe, Vyprvpn, NordVPN
 	Regions []string `json:"regions"`
 
 	// Cyberghost
 	Group string `json:"group"`
 
-	Countries []string `json:"countries"` // Fastestvpn, HideMyAss, Mullvad, PrivateVPN, PureVPN
-	Cities    []string `json:"cities"`    // HideMyAss, Mullvad, PrivateVPN, PureVPN, Windscribe
-	Hostnames []string `json:"hostnames"` // Fastestvpn, HideMyAss, PrivateVPN, Windscribe, Privado
+	Countries []string `json:"countries"` // Fastestvpn, HideMyAss, Mullvad, PrivateVPN, Protonvpn, PureVPN
+	Cities    []string `json:"cities"`    // HideMyAss, Mullvad, PrivateVPN, Protonvpn, PureVPN, Windscribe
+	Hostnames []string `json:"hostnames"` // Fastestvpn, HideMyAss, PrivateVPN, Windscribe, Privado, Protonvpn
+	Names     []string `json:"names"`     // Protonvpn
 
 	// Mullvad
 	ISPs  []string `json:"isps"`

internal/configuration/updater.go

@@ -18,6 +18,7 @@ type Updater struct {
 	PIA        bool          `json:"pia"`
 	Privado    bool          `json:"privado"`
 	Privatevpn bool          `json:"privatevpn"`
+	Protonvpn  bool          `json:"protonvpn"`
 	Purevpn    bool          `json:"purevpn"`
 	Surfshark  bool          `json:"surfshark"`
 	Torguard   bool          `json:"torguard"`
@@ -53,6 +54,7 @@ func (settings *Updater) read(r reader) (err error) {
 	settings.PIA = true
 	settings.Privado = true
 	settings.Privatevpn = true
+	settings.Protonvpn = true
 	settings.Purevpn = true
 	settings.Surfshark = true
 	settings.Torguard = true