Refactor (#174)

- Goal was to simplify main.go complexity
- Use common structures and interfaces for all vpn providers
- Moved files around
- Removed some alias models

internal/settings/cyberghost.go

@@ -1,54 +0,0 @@
-package settings
-
-import (
-	"strings"
-
-	"github.com/qdm12/private-internet-access-docker/internal/models"
-	"github.com/qdm12/private-internet-access-docker/internal/params"
-)
-
-// Windscribe contains the settings to connect to a Windscribe server
-type Cyberghost struct {
-	User      string
-	Password  string
-	ClientKey string
-	Group     models.CyberghostGroup
-	Region    models.CyberghostRegion
-}
-
-func (c *Cyberghost) String() string {
-	settingsList := []string{
-		"Cyberghost settings:",
-		"User: [redacted]",
-		"Password: [redacted]",
-		"ClientKey: [redacted]",
-		"Group: " + string(c.Group),
-		"Region: " + string(c.Region),
-	}
-	return strings.Join(settingsList, "\n |--")
-}
-
-// GetCyberghostSettings obtains Cyberghost settings from environment variables using the params package.
-func GetCyberghostSettings(paramsReader params.Reader) (settings Cyberghost, err error) {
-	settings.User, err = paramsReader.GetUser()
-	if err != nil {
-		return settings, err
-	}
-	settings.Password, err = paramsReader.GetPassword()
-	if err != nil {
-		return settings, err
-	}
-	settings.ClientKey, err = paramsReader.GetCyberghostClientKey()
-	if err != nil {
-		return settings, err
-	}
-	settings.Group, err = paramsReader.GetCyberghostGroup()
-	if err != nil {
-		return settings, err
-	}
-	settings.Region, err = paramsReader.GetCyberghostRegion()
-	if err != nil {
-		return settings, err
-	}
-	return settings, nil
-}

internal/settings/mullvad.go

@@ -1,56 +0,0 @@
-package settings
-
-import (
-	"strings"
-
-	"github.com/qdm12/private-internet-access-docker/internal/models"
-	"github.com/qdm12/private-internet-access-docker/internal/params"
-)
-
-// Mullvad contains the settings to connect to a Mullvad server
-type Mullvad struct {
-	User    string
-	Country models.MullvadCountry
-	City    models.MullvadCity
-	ISP     models.MullvadProvider
-	Port    uint16
-}
-
-func (m *Mullvad) String() string {
-	settingsList := []string{
-		"Mullvad settings:",
-		"User: [redacted]",
-		"Country: " + string(m.Country),
-		"City: " + string(m.City),
-		"ISP: " + string(m.ISP),
-		"Port: " + string(m.Port),
-	}
-	return strings.Join(settingsList, "\n |--")
-}
-
-// GetMullvadSettings obtains Mullvad settings from environment variables using the params package.
-func GetMullvadSettings(paramsReader params.Reader) (settings Mullvad, err error) {
-	settings.User, err = paramsReader.GetUser()
-	if err != nil {
-		return settings, err
-	}
-	// Remove spaces in user ID to simplify user's life, thanks @JeordyR
-	settings.User = strings.ReplaceAll(settings.User, " ", "")
-	settings.Country, err = paramsReader.GetMullvadCountry()
-	if err != nil {
-		return settings, err
-	}
-	settings.City, err = paramsReader.GetMullvadCity()
-	if err != nil {
-		return settings, err
-	}
-	settings.ISP, err = paramsReader.GetMullvadISP()
-	if err != nil {
-		return settings, err
-	}
-	settings.Port, err = paramsReader.GetMullvadPort()
-	if err != nil {
-		return settings, err
-	}
-	return settings, nil
-}

internal/settings/openvpn.go

@@ -2,26 +2,30 @@ package settings
 
 import (
 	"fmt"
-	"net"
 	"strings"
 
-	"github.com/qdm12/private-internet-access-docker/internal/models"
 	"github.com/qdm12/private-internet-access-docker/internal/params"
 )
 
 // OpenVPN contains settings to configure the OpenVPN client
 type OpenVPN struct {
-	NetworkProtocol models.NetworkProtocol
-	Verbosity       int
-	Root            bool
-	TargetIP        net.IP
-	Cipher          string
-	Auth            string
+	User      string
+	Password  string
+	Verbosity int
+	Root      bool
+	Cipher    string
+	Auth      string
 }
 
 // GetOpenVPNSettings obtains the OpenVPN settings using the params functions
 func GetOpenVPNSettings(paramsReader params.Reader) (settings OpenVPN, err error) {
-	settings.NetworkProtocol, err = paramsReader.GetNetworkProtocol()
+	settings.User, err = paramsReader.GetUser()
+	if err != nil {
+		return settings, err
+	}
+	// Remove spaces in user ID to simplify user's life, thanks @JeordyR
+	settings.User = strings.ReplaceAll(settings.User, " ", "")
+	settings.Password, err = paramsReader.GetPassword()
 	if err != nil {
 		return settings, err
 	}
@@ -33,10 +37,6 @@ func GetOpenVPNSettings(paramsReader params.Reader) (settings OpenVPN, err error
 	if err != nil {
 		return settings, err
 	}
-	settings.TargetIP, err = paramsReader.GetTargetIP()
-	if err != nil {
-		return settings, err
-	}
 	settings.Cipher, err = paramsReader.GetOpenVPNCipher()
 	if err != nil {
 		return settings, err
@@ -55,12 +55,16 @@ func (o *OpenVPN) String() string {
 	}
 	settingsList := []string{
 		"OpenVPN settings:",
-		"Network protocol: " + string(o.NetworkProtocol),
+		"User: [redacted]",
+		"Password: [redacted]",
 		"Verbosity level: " + fmt.Sprintf("%d", o.Verbosity),
 		"Run as root: " + runAsRoot,
-		"Target IP address: " + o.TargetIP.String(),
-		"Custom cipher: " + o.Cipher,
-		"Custom auth algorithm: " + o.Auth,
+	}
+	if len(o.Cipher) > 0 {
+		settingsList = append(settingsList, "Custom cipher: "+o.Cipher)
+	}
+	if len(o.Auth) > 0 {
+		settingsList = append(settingsList, "Custom auth algorithm: "+o.Auth)
 	}
 	return strings.Join(settingsList, "\n|--")
 }

internal/settings/pia.go

@@ -1,74 +0,0 @@
-package settings
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/qdm12/private-internet-access-docker/internal/models"
-	"github.com/qdm12/private-internet-access-docker/internal/params"
-)
-
-// PIA contains the settings to connect to a PIA server
-type PIA struct {
-	User           string
-	Password       string
-	Encryption     models.PIAEncryption
-	Region         models.PIARegion
-	PortForwarding PortForwarding
-}
-
-// PortForwarding contains settings for port forwarding
-type PortForwarding struct {
-	Enabled  bool
-	Filepath models.Filepath
-}
-
-func (p *PortForwarding) String() string {
-	if p.Enabled {
-		return fmt.Sprintf("on, saved in %s", p.Filepath)
-	}
-	return "off"
-}
-
-func (p *PIA) String() string {
-	settingsList := []string{
-		"PIA settings:",
-		"User: [redacted]",
-		"Password: [redacted]",
-		"Region: " + string(p.Region),
-		"Encryption: " + string(p.Encryption),
-		"Port forwarding: " + p.PortForwarding.String(),
-	}
-	return strings.Join(settingsList, "\n |--")
-}
-
-// GetPIASettings obtains PIA settings from environment variables using the params package.
-func GetPIASettings(paramsReader params.Reader) (settings PIA, err error) {
-	settings.User, err = paramsReader.GetUser()
-	if err != nil {
-		return settings, err
-	}
-	settings.Password, err = paramsReader.GetPassword()
-	if err != nil {
-		return settings, err
-	}
-	settings.Encryption, err = paramsReader.GetPIAEncryption()
-	if err != nil {
-		return settings, err
-	}
-	settings.Region, err = paramsReader.GetPIARegion()
-	if err != nil {
-		return settings, err
-	}
-	settings.PortForwarding.Enabled, err = paramsReader.GetPortForwarding()
-	if err != nil {
-		return settings, err
-	}
-	if settings.PortForwarding.Enabled {
-		settings.PortForwarding.Filepath, err = paramsReader.GetPortForwardingStatusFilepath()
-		if err != nil {
-			return settings, err
-		}
-	}
-	return settings, nil
-}

internal/settings/providers.go

@@ -0,0 +1,137 @@
+package settings
+
+import (
+	"github.com/qdm12/private-internet-access-docker/internal/constants"
+	"github.com/qdm12/private-internet-access-docker/internal/models"
+	"github.com/qdm12/private-internet-access-docker/internal/params"
+)
+
+// GetPIASettings obtains PIA settings from environment variables using the params package.
+func GetPIASettings(paramsReader params.Reader) (settings models.ProviderSettings, err error) {
+	settings.Name = constants.PrivateInternetAccess
+	settings.ServerSelection.Protocol, err = paramsReader.GetNetworkProtocol()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.TargetIP, err = paramsReader.GetTargetIP()
+	if err != nil {
+		return settings, err
+	}
+	encryptionPreset, err := paramsReader.GetPIAEncryptionPreset()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.EncryptionPreset = encryptionPreset
+	settings.ExtraConfigOptions.EncryptionPreset = encryptionPreset
+	settings.ServerSelection.Region, err = paramsReader.GetPIARegion()
+	if err != nil {
+		return settings, err
+	}
+	settings.PortForwarding.Enabled, err = paramsReader.GetPortForwarding()
+	if err != nil {
+		return settings, err
+	}
+	if settings.PortForwarding.Enabled {
+		settings.PortForwarding.Filepath, err = paramsReader.GetPortForwardingStatusFilepath()
+		if err != nil {
+			return settings, err
+		}
+	}
+	return settings, nil
+}
+
+// GetMullvadSettings obtains Mullvad settings from environment variables using the params package.
+func GetMullvadSettings(paramsReader params.Reader) (settings models.ProviderSettings, err error) {
+	settings.Name = constants.Mullvad
+	settings.ServerSelection.Protocol, err = paramsReader.GetNetworkProtocol()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.TargetIP, err = paramsReader.GetTargetIP()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.Country, err = paramsReader.GetMullvadCountry()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.City, err = paramsReader.GetMullvadCity()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.ISP, err = paramsReader.GetMullvadISP()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.CustomPort, err = paramsReader.GetMullvadPort()
+	if err != nil {
+		return settings, err
+	}
+	return settings, nil
+}
+
+// GetWindscribeSettings obtains Windscribe settings from environment variables using the params package.
+func GetWindscribeSettings(paramsReader params.Reader) (settings models.ProviderSettings, err error) {
+	settings.Name = constants.Windscribe
+	settings.ServerSelection.Protocol, err = paramsReader.GetNetworkProtocol()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.TargetIP, err = paramsReader.GetTargetIP()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.Region, err = paramsReader.GetWindscribeRegion()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.CustomPort, err = paramsReader.GetWindscribePort(settings.ServerSelection.Protocol)
+	if err != nil {
+		return settings, err
+	}
+	return settings, nil
+}
+
+// GetSurfsharkSettings obtains Surfshark settings from environment variables using the params package.
+func GetSurfsharkSettings(paramsReader params.Reader) (settings models.ProviderSettings, err error) {
+	settings.Name = constants.Surfshark
+	settings.ServerSelection.Protocol, err = paramsReader.GetNetworkProtocol()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.TargetIP, err = paramsReader.GetTargetIP()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.Region, err = paramsReader.GetSurfsharkRegion()
+	if err != nil {
+		return settings, err
+	}
+	return settings, nil
+}
+
+// GetCyberghostSettings obtains Cyberghost settings from environment variables using the params package.
+func GetCyberghostSettings(paramsReader params.Reader) (settings models.ProviderSettings, err error) {
+	settings.Name = constants.Cyberghost
+	settings.ServerSelection.Protocol, err = paramsReader.GetNetworkProtocol()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.TargetIP, err = paramsReader.GetTargetIP()
+	if err != nil {
+		return settings, err
+	}
+	settings.ExtraConfigOptions.ClientKey, err = paramsReader.GetCyberghostClientKey()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.Group, err = paramsReader.GetCyberghostGroup()
+	if err != nil {
+		return settings, err
+	}
+	settings.ServerSelection.Region, err = paramsReader.GetCyberghostRegion()
+	if err != nil {
+		return settings, err
+	}
+	return settings, nil
+}

internal/settings/settings.go

@@ -13,11 +13,7 @@ import (
 type Settings struct {
 	VPNSP       models.VPNProvider
 	OpenVPN     OpenVPN
-	PIA         PIA
-	Mullvad     Mullvad
-	Windscribe  Windscribe
-	Surfshark   Surfshark
-	Cyberghost  Cyberghost
+	Provider    models.ProviderSettings
 	System      System
 	DNS         DNS
 	Firewall    Firewall
@@ -26,23 +22,10 @@ type Settings struct {
 }
 
 func (s *Settings) String() string {
-	var vpnServiceProviderSettings string
-	switch s.VPNSP {
-	case constants.PrivateInternetAccess:
-		vpnServiceProviderSettings = s.PIA.String()
-	case constants.Mullvad:
-		vpnServiceProviderSettings = s.Mullvad.String()
-	case constants.Windscribe:
-		vpnServiceProviderSettings = s.Windscribe.String()
-	case constants.Surfshark:
-		vpnServiceProviderSettings = s.Surfshark.String()
-	case constants.Cyberghost:
-		vpnServiceProviderSettings = s.Cyberghost.String()
-	}
 	return strings.Join([]string{
 		"Settings summary below:",
 		s.OpenVPN.String(),
-		vpnServiceProviderSettings,
+		s.Provider.String(),
 		s.System.String(),
 		s.DNS.String(),
 		s.Firewall.String(),
@@ -59,27 +42,30 @@ func GetAllSettings(paramsReader params.Reader) (settings Settings, err error) {
 	if err != nil {
 		return settings, err
 	}
-	settings.OpenVPN, err = GetOpenVPNSettings(paramsReader)
-	if err != nil {
-		return settings, err
-	}
 	switch settings.VPNSP {
 	case constants.PrivateInternetAccess:
-		settings.PIA, err = GetPIASettings(paramsReader)
+		settings.Provider, err = GetPIASettings(paramsReader)
 	case constants.Mullvad:
-		settings.Mullvad, err = GetMullvadSettings(paramsReader)
+		settings.Provider, err = GetMullvadSettings(paramsReader)
 	case constants.Windscribe:
-		settings.Windscribe, err = GetWindscribeSettings(paramsReader, settings.OpenVPN.NetworkProtocol)
+		settings.Provider, err = GetWindscribeSettings(paramsReader)
 	case constants.Surfshark:
-		settings.Surfshark, err = GetSurfsharkSettings(paramsReader)
+		settings.Provider, err = GetSurfsharkSettings(paramsReader)
 	case constants.Cyberghost:
-		settings.Cyberghost, err = GetCyberghostSettings(paramsReader)
+		settings.Provider, err = GetCyberghostSettings(paramsReader)
 	default:
 		err = fmt.Errorf("VPN service provider %q is not valid", settings.VPNSP)
 	}
 	if err != nil {
 		return settings, err
 	}
+	settings.OpenVPN, err = GetOpenVPNSettings(paramsReader)
+	if err != nil {
+		return settings, err
+	}
+	if settings.VPNSP == constants.Mullvad {
+		settings.OpenVPN.Password = "m"
+	}
 	settings.DNS, err = GetDNSSettings(paramsReader)
 	if err != nil {
 		return settings, err

internal/settings/surfshark.go

@@ -1,42 +0,0 @@
-package settings
-
-import (
-	"strings"
-
-	"github.com/qdm12/private-internet-access-docker/internal/models"
-	"github.com/qdm12/private-internet-access-docker/internal/params"
-)
-
-// Surfshark contains the settings to connect to a Surfshark server
-type Surfshark struct {
-	User     string
-	Password string
-	Region   models.SurfsharkRegion
-}
-
-func (s *Surfshark) String() string {
-	settingsList := []string{
-		"Surfshark settings:",
-		"User: [redacted]",
-		"Password: [redacted]",
-		"Region: " + strings.Title(string(s.Region)),
-	}
-	return strings.Join(settingsList, "\n |--")
-}
-
-// GetSurfsharkSettings obtains Surfshark settings from environment variables using the params package.
-func GetSurfsharkSettings(paramsReader params.Reader) (settings Surfshark, err error) {
-	settings.User, err = paramsReader.GetUser()
-	if err != nil {
-		return settings, err
-	}
-	settings.Password, err = paramsReader.GetPassword()
-	if err != nil {
-		return settings, err
-	}
-	settings.Region, err = paramsReader.GetSurfsharkRegion()
-	if err != nil {
-		return settings, err
-	}
-	return settings, nil
-}

internal/settings/windscribe.go

@@ -1,49 +0,0 @@
-package settings
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/qdm12/private-internet-access-docker/internal/models"
-	"github.com/qdm12/private-internet-access-docker/internal/params"
-)
-
-// Windscribe contains the settings to connect to a Windscribe server
-type Windscribe struct {
-	User     string
-	Password string
-	Region   models.WindscribeRegion
-	Port     uint16
-}
-
-func (w *Windscribe) String() string {
-	settingsList := []string{
-		"Windscribe settings:",
-		"User: [redacted]",
-		"Password: [redacted]",
-		"Region: " + string(w.Region),
-		"Custom port: " + fmt.Sprintf("%d", w.Port),
-	}
-	return strings.Join(settingsList, "\n |--")
-}
-
-// GetWindscribeSettings obtains Windscribe settings from environment variables using the params package.
-func GetWindscribeSettings(paramsReader params.Reader, protocol models.NetworkProtocol) (settings Windscribe, err error) {
-	settings.User, err = paramsReader.GetUser()
-	if err != nil {
-		return settings, err
-	}
-	settings.Password, err = paramsReader.GetPassword()
-	if err != nil {
-		return settings, err
-	}
-	settings.Region, err = paramsReader.GetWindscribeRegion()
-	if err != nil {
-		return settings, err
-	}
-	settings.Port, err = paramsReader.GetWindscribePort(protocol)
-	if err != nil {
-		return settings, err
-	}
-	return settings, nil
-}