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

chore(config): rename Reader to Source struct

Browse Source
This commit is contained in:
Quentin McGaw
2022-08-26 15:16:51 +00:00
parent ae5cba519c
commit 8570e09eb9
28 changed files with 205 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
internal/configuration/sources/env/dns.go vendored
View File

@@ -7,8 +7,8 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readDNS() (dns settings.DNS, err error) {
dns.ServerAddress, err = r.readDNSServerAddress()
func (s *Source) readDNS() (dns settings.DNS, err error) {
dns.ServerAddress, err = s.readDNSServerAddress()
if err != nil {
return dns, err
}
@@ -18,7 +18,7 @@ func (r *Reader) readDNS() (dns settings.DNS, err error) {
return dns, fmt.Errorf("environment variable DNS_KEEP_NAMESERVER: %w", err)
}
dns.DoT, err = r.readDoT()
dns.DoT, err = s.readDoT()
if err != nil {
return dns, fmt.Errorf("DoT settings: %w", err)
}
@@ -26,22 +26,22 @@ func (r *Reader) readDNS() (dns settings.DNS, err error) {
return dns, nil
}
func (r *Reader) readDNSServerAddress() (address net.IP, err error) {
key, s := r.getEnvWithRetro("DNS_ADDRESS", "DNS_PLAINTEXT_ADDRESS")
if s == "" {
func (s *Source) readDNSServerAddress() (address net.IP, err error) {
key, value := s.getEnvWithRetro("DNS_ADDRESS", "DNS_PLAINTEXT_ADDRESS")
if value == "" {
return nil, nil
}
address = net.ParseIP(s)
address = net.ParseIP(value)
if address == nil {
return nil, fmt.Errorf("environment variable %s: %w: %s", key, ErrIPAddressParse, s)
return nil, fmt.Errorf("environment variable %s: %w: %s", key, ErrIPAddressParse, value)
}
// TODO remove in v4
if !address.Equal(net.IPv4(127, 0, 0, 1)) { //nolint:gomnd
r.warner.Warn(key + " is set to " + s +
s.warner.Warn(key + " is set to " + value +
" so the DNS over TLS (DoT) server will not be used." +
" The default value changed to 127.0.0.1 so it uses the internal DoT server." +
" The default value changed to 127.0.0.1 so it uses the internal DoT serves." +
" If the DoT server fails to start, the IPv4 address of the first plaintext DNS server" +
" corresponding to the first DoT provider chosen is used.")
}

8
internal/configuration/sources/env/dnsblacklist.go vendored
View File

@@ -9,13 +9,13 @@ import (
"inet.af/netaddr"
)
func (r *Reader) readDNSBlacklist() (blacklist settings.DNSBlacklist, err error) {
func (s *Source) readDNSBlacklist() (blacklist settings.DNSBlacklist, err error) {
blacklist.BlockMalicious, err = envToBoolPtr("BLOCK_MALICIOUS")
if err != nil {
return blacklist, fmt.Errorf("environment variable BLOCK_MALICIOUS: %w", err)
}
blacklist.BlockSurveillance, err = r.readBlockSurveillance()
blacklist.BlockSurveillance, err = s.readBlockSurveillance()
if err != nil {
return blacklist, err
}
@@ -36,8 +36,8 @@ func (r *Reader) readDNSBlacklist() (blacklist settings.DNSBlacklist, err error)
return blacklist, nil
}
func (r *Reader) readBlockSurveillance() (blocked *bool, err error) {
key, value := r.getEnvWithRetro("BLOCK_SURVEILLANCE", "BLOCK_NSA")
func (s *Source) readBlockSurveillance() (blocked *bool, err error) {
key, value := s.getEnvWithRetro("BLOCK_SURVEILLANCE", "BLOCK_NSA")
if value == "" {
return nil, nil //nolint:nilnil
}

4
internal/configuration/sources/env/dot.go vendored
View File

@@ -6,7 +6,7 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readDoT() (dot settings.DoT, err error) {
func (s *Source) readDoT() (dot settings.DoT, err error) {
dot.Enabled, err = envToBoolPtr("DOT")
if err != nil {
return dot, fmt.Errorf("environment variable DOT: %w", err)
@@ -22,7 +22,7 @@ func (r *Reader) readDoT() (dot settings.DoT, err error) {
return dot, err
}
dot.Blacklist, err = r.readDNSBlacklist()
dot.Blacklist, err = s.readDNSBlacklist()
if err != nil {
return dot, err
}

4
internal/configuration/sources/env/firewall.go vendored
View File

@@ -9,7 +9,7 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readFirewall() (firewall settings.Firewall, err error) {
func (s *Source) readFirewall() (firewall settings.Firewall, err error) {
vpnInputPortStrings := envToCSV("FIREWALL_VPN_INPUT_PORTS")
firewall.VPNInputPorts, err = stringsToPorts(vpnInputPortStrings)
if err != nil {
@@ -22,7 +22,7 @@ func (r *Reader) readFirewall() (firewall settings.Firewall, err error) {
return firewall, fmt.Errorf("environment variable FIREWALL_INPUT_PORTS: %w", err)
}
outboundSubnetsKey, _ := r.getEnvWithRetro("FIREWALL_OUTBOUND_SUBNETS", "EXTRA_SUBNETS")
outboundSubnetsKey, _ := s.getEnvWithRetro("FIREWALL_OUTBOUND_SUBNETS", "EXTRA_SUBNETS")
outboundSubnetStrings := envToCSV(outboundSubnetsKey)
firewall.OutboundSubnets, err = stringsToIPNets(outboundSubnetStrings)
if err != nil {

16
internal/configuration/sources/env/health.go vendored
View File

@@ -7,18 +7,18 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) ReadHealth() (health settings.Health, err error) {
func (s *Source) ReadHealth() (health settings.Health, err error) {
health.ServerAddress = getCleanedEnv("HEALTH_SERVER_ADDRESS")
_, health.TargetAddress = r.getEnvWithRetro("HEALTH_TARGET_ADDRESS", "HEALTH_ADDRESS_TO_PING")
_, health.TargetAddress = s.getEnvWithRetro("HEALTH_TARGET_ADDRESS", "HEALTH_ADDRESS_TO_PING")
health.VPN.Initial, err = r.readDurationWithRetro(
health.VPN.Initial, err = s.readDurationWithRetro(
"HEALTH_VPN_DURATION_INITIAL",
"HEALTH_OPENVPN_DURATION_INITIAL")
if err != nil {
return health, err
}
health.VPN.Addition, err = r.readDurationWithRetro(
health.VPN.Addition, err = s.readDurationWithRetro(
"HEALTH_VPN_DURATION_ADDITION",
"HEALTH_OPENVPN_DURATION_ADDITION")
if err != nil {
@@ -28,14 +28,14 @@ func (r *Reader) ReadHealth() (health settings.Health, err error) {
return health, nil
}
func (r *Reader) readDurationWithRetro(envKey, retroEnvKey string) (d *time.Duration, err error) {
envKey, s := r.getEnvWithRetro(envKey, retroEnvKey)
if s == "" {
func (s *Source) readDurationWithRetro(envKey, retroEnvKey string) (d *time.Duration, err error) {
envKey, value := s.getEnvWithRetro(envKey, retroEnvKey)
if value == "" {
return nil, nil //nolint:nilnil
}
d = new(time.Duration)
*d, err = time.ParseDuration(s)
*d, err = time.ParseDuration(value)
if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", envKey, err)
}

48
internal/configuration/sources/env/httproxy.go vendored
View File

@@ -7,12 +7,12 @@ import (
"github.com/qdm12/govalid/binary"
)
func (r *Reader) readHTTPProxy() (httpProxy settings.HTTPProxy, err error) {
httpProxy.User = r.readHTTProxyUser()
httpProxy.Password = r.readHTTProxyPassword()
httpProxy.ListeningAddress = r.readHTTProxyListeningAddress()
func (s *Source) readHTTPProxy() (httpProxy settings.HTTPProxy, err error) {
httpProxy.User = s.readHTTProxyUser()
httpProxy.Password = s.readHTTProxyPassword()
httpProxy.ListeningAddress = s.readHTTProxyListeningAddress()
httpProxy.Enabled, err = r.readHTTProxyEnabled()
httpProxy.Enabled, err = s.readHTTProxyEnabled()
if err != nil {
return httpProxy, err
}
@@ -22,7 +22,7 @@ func (r *Reader) readHTTPProxy() (httpProxy settings.HTTPProxy, err error) {
return httpProxy, fmt.Errorf("environment variable HTTPPROXY_STEALTH: %w", err)
}
httpProxy.Log, err = r.readHTTProxyLog()
httpProxy.Log, err = s.readHTTProxyLog()
if err != nil {
return httpProxy, err
}
@@ -30,38 +30,38 @@ func (r *Reader) readHTTPProxy() (httpProxy settings.HTTPProxy, err error) {
return httpProxy, nil
}
func (r *Reader) readHTTProxyUser() (user *string) {
_, s := r.getEnvWithRetro("HTTPPROXY_USER", "PROXY_USER", "TINYPROXY_USER")
if s != "" {
return &s
func (s *Source) readHTTProxyUser() (user *string) {
_, value := s.getEnvWithRetro("HTTPPROXY_USER", "PROXY_USER", "TINYPROXY_USER")
if value != "" {
return &value
}
return nil
}
func (r *Reader) readHTTProxyPassword() (user *string) {
_, s := r.getEnvWithRetro("HTTPPROXY_PASSWORD", "PROXY_PASSWORD", "TINYPROXY_PASSWORD")
if s != "" {
return &s
func (s *Source) readHTTProxyPassword() (user *string) {
_, value := s.getEnvWithRetro("HTTPPROXY_PASSWORD", "PROXY_PASSWORD", "TINYPROXY_PASSWORD")
if value != "" {
return &value
}
return nil
}
func (r *Reader) readHTTProxyListeningAddress() (listeningAddress string) {
key, value := r.getEnvWithRetro("HTTPPROXY_LISTENING_ADDRESS", "PROXY_PORT", "TINYPROXY_PORT", "HTTPPROXY_PORT")
func (s *Source) readHTTProxyListeningAddress() (listeningAddress string) {
key, value := s.getEnvWithRetro("HTTPPROXY_LISTENING_ADDRESS", "PROXY_PORT", "TINYPROXY_PORT", "HTTPPROXY_PORT")
if key == "HTTPPROXY_LISTENING_ADDRESS" {
return value
}
return ":" + value
}
func (r *Reader) readHTTProxyEnabled() (enabled *bool, err error) {
key, s := r.getEnvWithRetro("HTTPPROXY", "PROXY", "TINYPROXY")
if s == "" {
func (s *Source) readHTTProxyEnabled() (enabled *bool, err error) {
key, value := s.getEnvWithRetro("HTTPPROXY", "PROXY", "TINYPROXY")
if value == "" {
return nil, nil //nolint:nilnil
}
enabled = new(bool)
*enabled, err = binary.Validate(s)
*enabled, err = binary.Validate(value)
if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", key, err)
}
@@ -69,9 +69,9 @@ func (r *Reader) readHTTProxyEnabled() (enabled *bool, err error) {
return enabled, nil
}
func (r *Reader) readHTTProxyLog() (enabled *bool, err error) {
key, s := r.getEnvWithRetro("HTTPPROXY_LOG", "PROXY_LOG_LEVEL", "TINYPROXY_LOG")
if s == "" {
func (s *Source) readHTTProxyLog() (enabled *bool, err error) {
key, value := s.getEnvWithRetro("HTTPPROXY_LOG", "PROXY_LOG_LEVEL", "TINYPROXY_LOG")
if value == "" {
return nil, nil //nolint:nilnil
}
@@ -82,7 +82,7 @@ func (r *Reader) readHTTProxyLog() (enabled *bool, err error) {
}
enabled = new(bool)
*enabled, err = binary.Validate(s, binaryOptions...)
*enabled, err = binary.Validate(value, binaryOptions...)
if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", key, err)
}

34
internal/configuration/sources/env/openvpn.go vendored
View File

@@ -8,7 +8,7 @@ import (
"github.com/qdm12/govalid/binary"
)
func (r *Reader) readOpenVPN() (
func (s *Source) readOpenVPN() (
openVPN settings.OpenVPN, err error) {
defer func() {
err = unsetEnvKeys([]string{"OPENVPN_KEY", "OPENVPN_CERT",
@@ -16,14 +16,14 @@ func (r *Reader) readOpenVPN() (
}()
openVPN.Version = getCleanedEnv("OPENVPN_VERSION")
openVPN.User = r.readOpenVPNUser()
openVPN.Password = r.readOpenVPNPassword()
openVPN.User = s.readOpenVPNUser()
openVPN.Password = s.readOpenVPNPassword()
confFile := getCleanedEnv("OPENVPN_CUSTOM_CONFIG")
if confFile != "" {
openVPN.ConfFile = &confFile
}
ciphersKey, _ := r.getEnvWithRetro("OPENVPN_CIPHERS", "OPENVPN_CIPHER")
ciphersKey, _ := s.getEnvWithRetro("OPENVPN_CIPHERS", "OPENVPN_CIPHER")
openVPN.Ciphers = envToCSV(ciphersKey)
auth := getCleanedEnv("OPENVPN_AUTH")
@@ -35,9 +35,9 @@ func (r *Reader) readOpenVPN() (
openVPN.Key = envToStringPtr("OPENVPN_KEY")
openVPN.EncryptedKey = envToStringPtr("OPENVPN_ENCRYPTED_KEY")
openVPN.KeyPassphrase = r.readOpenVPNKeyPassphrase()
openVPN.KeyPassphrase = s.readOpenVPNKeyPassphrase()
openVPN.PIAEncPreset = r.readPIAEncryptionPreset()
openVPN.PIAEncPreset = s.readPIAEncryptionPreset()
openVPN.IPv6, err = envToBoolPtr("OPENVPN_IPV6")
if err != nil {
@@ -49,9 +49,9 @@ func (r *Reader) readOpenVPN() (
return openVPN, fmt.Errorf("environment variable OPENVPN_MSSFIX: %w", err)
}
_, openVPN.Interface = r.getEnvWithRetro("VPN_INTERFACE", "OPENVPN_INTERFACE")
_, openVPN.Interface = s.getEnvWithRetro("VPN_INTERFACE", "OPENVPN_INTERFACE")
openVPN.ProcessUser, err = r.readOpenVPNProcessUser()
openVPN.ProcessUser, err = s.readOpenVPNProcessUser()
if err != nil {
return openVPN, err
}
@@ -69,9 +69,9 @@ func (r *Reader) readOpenVPN() (
return openVPN, nil
}
func (r *Reader) readOpenVPNUser() (user *string) {
func (s *Source) readOpenVPNUser() (user *string) {
user = new(string)
_, *user = r.getEnvWithRetro("OPENVPN_USER", "USER")
_, *user = s.getEnvWithRetro("OPENVPN_USER", "USER")
if *user == "" {
return nil
}
@@ -81,9 +81,9 @@ func (r *Reader) readOpenVPNUser() (user *string) {
return user
}
func (r *Reader) readOpenVPNPassword() (password *string) {
func (s *Source) readOpenVPNPassword() (password *string) {
password = new(string)
_, *password = r.getEnvWithRetro("OPENVPN_PASSWORD", "PASSWORD")
_, *password = s.getEnvWithRetro("OPENVPN_PASSWORD", "PASSWORD")
if *password == "" {
return nil
}
@@ -91,7 +91,7 @@ func (r *Reader) readOpenVPNPassword() (password *string) {
return password
}
func (r *Reader) readOpenVPNKeyPassphrase() (passphrase *string) {
func (s *Source) readOpenVPNKeyPassphrase() (passphrase *string) {
passphrase = new(string)
*passphrase = getCleanedEnv("OPENVPN_KEY_PASSPHRASE")
if *passphrase == "" {
@@ -100,8 +100,8 @@ func (r *Reader) readOpenVPNKeyPassphrase() (passphrase *string) {
return passphrase
}
func (r *Reader) readPIAEncryptionPreset() (presetPtr *string) {
_, preset := r.getEnvWithRetro(
func (s *Source) readPIAEncryptionPreset() (presetPtr *string) {
_, preset := s.getEnvWithRetro(
"PRIVATE_INTERNET_ACCESS_OPENVPN_ENCRYPTION_PRESET",
"PIA_ENCRYPTION", "ENCRYPTION")
if preset != "" {
@@ -110,8 +110,8 @@ func (r *Reader) readPIAEncryptionPreset() (presetPtr *string) {
return nil
}
func (r *Reader) readOpenVPNProcessUser() (processUser string, err error) {
key, value := r.getEnvWithRetro("OPENVPN_PROCESS_USER", "OPENVPN_ROOT")
func (s *Source) readOpenVPNProcessUser() (processUser string, err error) {
key, value := s.getEnvWithRetro("OPENVPN_PROCESS_USER", "OPENVPN_ROOT")
if key == "OPENVPN_PROCESS_USER" {
return value, nil
}

20
internal/configuration/sources/env/openvpnselection.go vendored
View File

@@ -10,32 +10,32 @@ import (
"github.com/qdm12/govalid/port"
)
func (r *Reader) readOpenVPNSelection() (
func (s *Source) readOpenVPNSelection() (
selection settings.OpenVPNSelection, err error) {
confFile := getCleanedEnv("OPENVPN_CUSTOM_CONFIG")
if confFile != "" {
selection.ConfFile = &confFile
}
selection.TCP, err = r.readOpenVPNProtocol()
selection.TCP, err = s.readOpenVPNProtocol()
if err != nil {
return selection, err
}
selection.CustomPort, err = r.readOpenVPNCustomPort()
selection.CustomPort, err = s.readOpenVPNCustomPort()
if err != nil {
return selection, err
}
selection.PIAEncPreset = r.readPIAEncryptionPreset()
selection.PIAEncPreset = s.readPIAEncryptionPreset()
return selection, nil
}
var ErrOpenVPNProtocolNotValid = errors.New("OpenVPN protocol is not valid")
func (r *Reader) readOpenVPNProtocol() (tcp *bool, err error) {
envKey, protocol := r.getEnvWithRetro("OPENVPN_PROTOCOL", "PROTOCOL")
func (s *Source) readOpenVPNProtocol() (tcp *bool, err error) {
envKey, protocol := s.getEnvWithRetro("OPENVPN_PROTOCOL", "PROTOCOL")
switch strings.ToLower(protocol) {
case "":
@@ -50,14 +50,14 @@ func (r *Reader) readOpenVPNProtocol() (tcp *bool, err error) {
}
}
func (r *Reader) readOpenVPNCustomPort() (customPort *uint16, err error) {
key, s := r.getEnvWithRetro("VPN_ENDPOINT_PORT", "PORT", "OPENVPN_PORT")
if s == "" {
func (s *Source) readOpenVPNCustomPort() (customPort *uint16, err error) {
key, value := s.getEnvWithRetro("VPN_ENDPOINT_PORT", "PORT", "OPENVPN_PORT")
if value == "" {
return nil, nil //nolint:nilnil
}
customPort = new(uint16)
*customPort, err = port.Validate(s)
*customPort, err = port.Validate(value)
if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", key, err)
}

6
internal/configuration/sources/env/portforward.go vendored
View File

@@ -6,9 +6,9 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readPortForward() (
func (s *Source) readPortForward() (
portForwarding settings.PortForwarding, err error) {
key, _ := r.getEnvWithRetro(
key, _ := s.getEnvWithRetro(
"PRIVATE_INTERNET_ACCESS_VPN_PORT_FORWARDING",
"PORT_FORWARDING")
portForwarding.Enabled, err = envToBoolPtr(key)
@@ -16,7 +16,7 @@ func (r *Reader) readPortForward() (
return portForwarding, fmt.Errorf("environment variable %s: %w", key, err)
}
_, value := r.getEnvWithRetro(
_, value := s.getEnvWithRetro(
"PRIVATE_INTERNET_ACCESS_VPN_PORT_FORWARDING_STATUS_FILE",
"PORT_FORWARDING_STATUS_FILE")
if value != "" {

20
internal/configuration/sources/env/provider.go vendored
View File

@@ -9,19 +9,19 @@ import (
"github.com/qdm12/gluetun/internal/constants/vpn"
)
func (r *Reader) readProvider(vpnType string) (provider settings.Provider, err error) {
provider.Name = r.readVPNServiceProvider(vpnType)
func (s *Source) readProvider(vpnType string) (provider settings.Provider, err error) {
provider.Name = s.readVPNServiceProvider(vpnType)
var providerName string
if provider.Name != nil {
providerName = *provider.Name
}
provider.ServerSelection, err = r.readServerSelection(providerName, vpnType)
provider.ServerSelection, err = s.readServerSelection(providerName, vpnType)
if err != nil {
return provider, fmt.Errorf("server selection: %w", err)
}
provider.PortForwarding, err = r.readPortForward()
provider.PortForwarding, err = s.readPortForward()
if err != nil {
return provider, fmt.Errorf("port forwarding: %w", err)
}
@@ -29,9 +29,9 @@ func (r *Reader) readProvider(vpnType string) (provider settings.Provider, err e
return provider, nil
}
func (r *Reader) readVPNServiceProvider(vpnType string) (vpnProviderPtr *string) {
_, s := r.getEnvWithRetro("VPN_SERVICE_PROVIDER", "VPNSP")
if s == "" {
func (s *Source) readVPNServiceProvider(vpnType string) (vpnProviderPtr *string) {
_, value := s.getEnvWithRetro("VPN_SERVICE_PROVIDER", "VPNSP")
if value == "" {
if vpnType != vpn.Wireguard && getCleanedEnv("OPENVPN_CUSTOM_CONFIG") != "" {
// retro compatibility
return stringPtr(providers.Custom)
@@ -39,10 +39,10 @@ func (r *Reader) readVPNServiceProvider(vpnType string) (vpnProviderPtr *string)
return nil
}
s = strings.ToLower(s)
if s == "pia" { // retro compatibility
value = strings.ToLower(value)
if value == "pia" { // retro compatibility
return stringPtr(providers.PrivateInternetAccess)
}
return stringPtr(s)
return stringPtr(value)
}

12
internal/configuration/sources/env/publicip.go vendored
View File

@@ -7,13 +7,13 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readPublicIP() (publicIP settings.PublicIP, err error) {
func (s *Source) readPublicIP() (publicIP settings.PublicIP, err error) {
publicIP.Period, err = readPublicIPPeriod()
if err != nil {
return publicIP, err
}
publicIP.IPFilepath = r.readPublicIPFilepath()
publicIP.IPFilepath = s.readPublicIPFilepath()
return publicIP, nil
}
@@ -33,10 +33,10 @@ func readPublicIPPeriod() (period *time.Duration, err error) {
return period, nil
}
func (r *Reader) readPublicIPFilepath() (filepath *string) {
_, s := r.getEnvWithRetro("PUBLICIP_FILE", "IP_STATUS_FILE")
if s != "" {
return &s
func (s *Source) readPublicIPFilepath() (filepath *string) {
_, value := s.getEnvWithRetro("PUBLICIP_FILE", "IP_STATUS_FILE")
if value != "" {
return &value
}
return nil
}

36
internal/configuration/sources/env/reader.go vendored
View File

@@ -4,7 +4,7 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
type Reader struct {
type Source struct {
warner Warner
}
@@ -12,36 +12,36 @@ type Warner interface {
Warn(s string)
}
func New(warner Warner) *Reader {
return &Reader{
func New(warner Warner) *Source {
return &Source{
warner: warner,
}
}
func (r *Reader) String() string { return "environment variables" }
func (s *Source) String() string { return "environment variables" }
func (r *Reader) Read() (settings settings.Settings, err error) {
settings.VPN, err = r.readVPN()
func (s *Source) Read() (settings settings.Settings, err error) {
settings.VPN, err = s.readVPN()
if err != nil {
return settings, err
}
settings.Firewall, err = r.readFirewall()
settings.Firewall, err = s.readFirewall()
if err != nil {
return settings, err
}
settings.System, err = r.readSystem()
settings.System, err = s.readSystem()
if err != nil {
return settings, err
}
settings.Health, err = r.ReadHealth()
settings.Health, err = s.ReadHealth()
if err != nil {
return settings, err
}
settings.HTTPProxy, err = r.readHTTPProxy()
settings.HTTPProxy, err = s.readHTTPProxy()
if err != nil {
return settings, err
}
@@ -51,7 +51,7 @@ func (r *Reader) Read() (settings settings.Settings, err error) {
return settings, err
}
settings.PublicIP, err = r.readPublicIP()
settings.PublicIP, err = s.readPublicIP()
if err != nil {
return settings, err
}
@@ -66,17 +66,17 @@ func (r *Reader) Read() (settings settings.Settings, err error) {
return settings, err
}
settings.Shadowsocks, err = r.readShadowsocks()
settings.Shadowsocks, err = s.readShadowsocks()
if err != nil {
return settings, err
}
settings.DNS, err = r.readDNS()
settings.DNS, err = s.readDNS()
if err != nil {
return settings, err
}
settings.ControlServer, err = r.readControlServer()
settings.ControlServer, err = s.readControlServer()
if err != nil {
return settings, err
}
@@ -89,8 +89,8 @@ func (r *Reader) Read() (settings settings.Settings, err error) {
return settings, nil
}
func (r *Reader) onRetroActive(oldKey, newKey string) {
r.warner.Warn(
func (s *Source) onRetroActive(oldKey, newKey string) {
s.warner.Warn(
"You are using the old environment variable " + oldKey +
", please consider changing it to " + newKey)
}
@@ -101,14 +101,14 @@ func (r *Reader) onRetroActive(oldKey, newKey string) {
// and end on returning the value corresponding to the currentKey.
// Note retroKeys should be in order from oldest to most
// recent retro-compatibility key.
func (r *Reader) getEnvWithRetro(currentKey string,
func (s *Source) getEnvWithRetro(currentKey string,
retroKeys ...string) (key, value string) {
// We check retro-compatibility keys first since
// the current key might be set in the Dockerfile.
for _, key = range retroKeys {
value = getCleanedEnv(key)
if value != "" {
r.onRetroActive(key, currentKey)
s.onRetroActive(key, currentKey)
return key, value
}
}

14
internal/configuration/sources/env/server.go vendored
View File

@@ -7,13 +7,13 @@ import (
"github.com/qdm12/govalid/binary"
)
func (r *Reader) readControlServer() (controlServer settings.ControlServer, err error) {
func (s *Source) readControlServer() (controlServer settings.ControlServer, err error) {
controlServer.Log, err = readControlServerLog()
if err != nil {
return controlServer, err
}
controlServer.Address = r.readControlServerAddress()
controlServer.Address = s.readControlServerAddress()
return controlServer, nil
}
@@ -32,17 +32,17 @@ func readControlServerLog() (enabled *bool, err error) {
return &log, nil
}
func (r *Reader) readControlServerAddress() (address *string) {
key, s := r.getEnvWithRetro("HTTP_CONTROL_SERVER_ADDRESS", "HTTP_CONTROL_SERVER_PORT")
if s == "" {
func (s *Source) readControlServerAddress() (address *string) {
key, value := s.getEnvWithRetro("HTTP_CONTROL_SERVER_ADDRESS", "HTTP_CONTROL_SERVER_PORT")
if value == "" {
return nil
}
if key == "HTTP_CONTROL_SERVER_ADDRESS" {
return &s
return &value
}
address = new(string)
*address = ":" + s
*address = ":" + value
return address
}

36
internal/configuration/sources/env/serverselection.go vendored
View File

@@ -15,37 +15,37 @@ var (
ErrServerNumberNotValid = errors.New("server number is not valid")
)
func (r *Reader) readServerSelection(vpnProvider, vpnType string) (
func (s *Source) readServerSelection(vpnProvider, vpnType string) (
ss settings.ServerSelection, err error) {
ss.VPN = vpnType
ss.TargetIP, err = r.readOpenVPNTargetIP()
ss.TargetIP, err = s.readOpenVPNTargetIP()
if err != nil {
return ss, err
}
countriesKey, _ := r.getEnvWithRetro("SERVER_COUNTRIES", "COUNTRY")
countriesKey, _ := s.getEnvWithRetro("SERVER_COUNTRIES", "COUNTRY")
ss.Countries = envToCSV(countriesKey)
if vpnProvider == providers.Cyberghost && len(ss.Countries) == 0 {
// Retro-compatibility for Cyberghost using the REGION variable
ss.Countries = envToCSV("REGION")
if len(ss.Countries) > 0 {
r.onRetroActive("REGION", "SERVER_COUNTRIES")
s.onRetroActive("REGION", "SERVER_COUNTRIES")
}
}
regionsKey, _ := r.getEnvWithRetro("SERVER_REGIONS", "REGION")
regionsKey, _ := s.getEnvWithRetro("SERVER_REGIONS", "REGION")
ss.Regions = envToCSV(regionsKey)
citiesKey, _ := r.getEnvWithRetro("SERVER_CITIES", "CITY")
citiesKey, _ := s.getEnvWithRetro("SERVER_CITIES", "CITY")
ss.Cities = envToCSV(citiesKey)
ss.ISPs = envToCSV("ISP")
hostnamesKey, _ := r.getEnvWithRetro("SERVER_HOSTNAMES", "SERVER_HOSTNAME")
hostnamesKey, _ := s.getEnvWithRetro("SERVER_HOSTNAMES", "SERVER_HOSTNAME")
ss.Hostnames = envToCSV(hostnamesKey)
serverNamesKey, _ := r.getEnvWithRetro("SERVER_NAMES", "SERVER_NAME")
serverNamesKey, _ := s.getEnvWithRetro("SERVER_NAMES", "SERVER_NAME")
ss.Names = envToCSV(serverNamesKey)
if csv := getCleanedEnv("SERVER_NUMBER"); csv != "" {
@@ -66,7 +66,7 @@ func (r *Reader) readServerSelection(vpnProvider, vpnType string) (
}
// Mullvad only
ss.OwnedOnly, err = r.readOwnedOnly()
ss.OwnedOnly, err = s.readOwnedOnly()
if err != nil {
return ss, err
}
@@ -95,12 +95,12 @@ func (r *Reader) readServerSelection(vpnProvider, vpnType string) (
return ss, fmt.Errorf("environment variable STREAM_ONLY: %w", err)
}
ss.OpenVPN, err = r.readOpenVPNSelection()
ss.OpenVPN, err = s.readOpenVPNSelection()
if err != nil {
return ss, err
}
ss.Wireguard, err = r.readWireguardSelection()
ss.Wireguard, err = s.readWireguardSelection()
if err != nil {
return ss, err
}
@@ -112,23 +112,23 @@ var (
ErrInvalidIP = errors.New("invalid IP address")
)
func (r *Reader) readOpenVPNTargetIP() (ip net.IP, err error) {
envKey, s := r.getEnvWithRetro("VPN_ENDPOINT_IP", "OPENVPN_TARGET_IP")
if s == "" {
func (s *Source) readOpenVPNTargetIP() (ip net.IP, err error) {
envKey, value := s.getEnvWithRetro("VPN_ENDPOINT_IP", "OPENVPN_TARGET_IP")
if value == "" {
return nil, nil
}
ip = net.ParseIP(s)
ip = net.ParseIP(value)
if ip == nil {
return nil, fmt.Errorf("environment variable %s: %w: %s",
envKey, ErrInvalidIP, s)
envKey, ErrInvalidIP, value)
}
return ip, nil
}
func (r *Reader) readOwnedOnly() (ownedOnly *bool, err error) {
envKey, _ := r.getEnvWithRetro("OWNED_ONLY", "OWNED")
func (s *Source) readOwnedOnly() (ownedOnly *bool, err error) {
envKey, _ := s.getEnvWithRetro("OWNED_ONLY", "OWNED")
ownedOnly, err = envToBoolPtr(envKey)
if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", envKey, err)

14
internal/configuration/sources/env/shadowsocks.go vendored
View File

@@ -7,25 +7,25 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readShadowsocks() (shadowsocks settings.Shadowsocks, err error) {
func (s *Source) readShadowsocks() (shadowsocks settings.Shadowsocks, err error) {
shadowsocks.Enabled, err = envToBoolPtr("SHADOWSOCKS")
if err != nil {
return shadowsocks, fmt.Errorf("environment variable SHADOWSOCKS: %w", err)
}
shadowsocks.Address = r.readShadowsocksAddress()
shadowsocks.Address = s.readShadowsocksAddress()
shadowsocks.LogAddresses, err = envToBoolPtr("SHADOWSOCKS_LOG")
if err != nil {
return shadowsocks, fmt.Errorf("environment variable SHADOWSOCKS_LOG: %w", err)
}
shadowsocks.CipherName = r.readShadowsocksCipher()
shadowsocks.CipherName = s.readShadowsocksCipher()
shadowsocks.Password = envToStringPtr("SHADOWSOCKS_PASSWORD")
return shadowsocks, nil
}
func (r *Reader) readShadowsocksAddress() (address string) {
key, value := r.getEnvWithRetro("SHADOWSOCKS_LISTENING_ADDRESS", "SHADOWSOCKS_PORT")
func (s *Source) readShadowsocksAddress() (address string) {
key, value := s.getEnvWithRetro("SHADOWSOCKS_LISTENING_ADDRESS", "SHADOWSOCKS_PORT")
if value == "" {
return ""
}
@@ -38,7 +38,7 @@ func (r *Reader) readShadowsocksAddress() (address string) {
return ":" + value
}
func (r *Reader) readShadowsocksCipher() (cipher string) {
_, cipher = r.getEnvWithRetro("SHADOWSOCKS_CIPHER", "SHADOWSOCKS_METHOD")
func (s *Source) readShadowsocksCipher() (cipher string) {
_, cipher = s.getEnvWithRetro("SHADOWSOCKS_CIPHER", "SHADOWSOCKS_METHOD")
return strings.ToLower(cipher)
}

10
internal/configuration/sources/env/system.go vendored
View File

@@ -14,13 +14,13 @@ var (
ErrSystemTimezoneNotValid = errors.New("timezone is not valid")
)
func (r *Reader) readSystem() (system settings.System, err error) {
system.PUID, err = r.readID("PUID", "UID")
func (s *Source) readSystem() (system settings.System, err error) {
system.PUID, err = s.readID("PUID", "UID")
if err != nil {
return system, err
}
system.PGID, err = r.readID("PGID", "GID")
system.PGID, err = s.readID("PGID", "GID")
if err != nil {
return system, err
}
@@ -32,9 +32,9 @@ func (r *Reader) readSystem() (system settings.System, err error) {
var ErrSystemIDNotValid = errors.New("system ID is not valid")
func (r *Reader) readID(key, retroKey string) (
func (s *Source) readID(key, retroKey string) (
id *uint32, err error) {
idEnvKey, idString := r.getEnvWithRetro(key, retroKey)
idEnvKey, idString := s.getEnvWithRetro(key, retroKey)
if idString == "" {
return nil, nil //nolint:nilnil
}

4
internal/configuration/sources/env/system_test.go vendored
View File

@@ -74,8 +74,8 @@ func Test_Reader_readID(t *testing.T) {
setTestEnv(t, key, testCase.keyValue)
setTestEnv(t, retroKey, testCase.retroValue)
reader := &Reader{}
id, err := reader.readID(key, retroKey)
source := &Source{}
id, err := source.readID(key, retroKey)
assert.ErrorIs(t, err, testCase.errWrapped)
if err != nil {

8
internal/configuration/sources/env/vpn.go vendored
View File

@@ -7,20 +7,20 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readVPN() (vpn settings.VPN, err error) {
func (s *Source) readVPN() (vpn settings.VPN, err error) {
vpn.Type = strings.ToLower(getCleanedEnv("VPN_TYPE"))
vpn.Provider, err = r.readProvider(vpn.Type)
vpn.Provider, err = s.readProvider(vpn.Type)
if err != nil {
return vpn, fmt.Errorf("VPN provider: %w", err)
}
vpn.OpenVPN, err = r.readOpenVPN()
vpn.OpenVPN, err = s.readOpenVPN()
if err != nil {
return vpn, fmt.Errorf("OpenVPN: %w", err)
}
vpn.Wireguard, err = r.readWireguard()
vpn.Wireguard, err = s.readWireguard()
if err != nil {
return vpn, fmt.Errorf("wireguard: %w", err)
}

10
internal/configuration/sources/env/wireguard.go vendored
View File

@@ -8,22 +8,22 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readWireguard() (wireguard settings.Wireguard, err error) {
func (s *Source) readWireguard() (wireguard settings.Wireguard, err error) {
defer func() {
err = unsetEnvKeys([]string{"WIREGUARD_PRIVATE_KEY", "WIREGUARD_PRESHARED_KEY"}, err)
}()
wireguard.PrivateKey = envToStringPtr("WIREGUARD_PRIVATE_KEY")
wireguard.PreSharedKey = envToStringPtr("WIREGUARD_PRESHARED_KEY")
_, wireguard.Interface = r.getEnvWithRetro("VPN_INTERFACE", "WIREGUARD_INTERFACE")
wireguard.Addresses, err = r.readWireguardAddresses()
_, wireguard.Interface = s.getEnvWithRetro("VPN_INTERFACE", "WIREGUARD_INTERFACE")
wireguard.Addresses, err = s.readWireguardAddresses()
if err != nil {
return wireguard, err // already wrapped
}
return wireguard, nil
}
func (r *Reader) readWireguardAddresses() (addresses []net.IPNet, err error) {
key, addressesCSV := r.getEnvWithRetro("WIREGUARD_ADDRESSES", "WIREGUARD_ADDRESS")
func (s *Source) readWireguardAddresses() (addresses []net.IPNet, err error) {
key, addressesCSV := s.getEnvWithRetro("WIREGUARD_ADDRESSES", "WIREGUARD_ADDRESS")
if addressesCSV == "" {
return nil, nil
}

24
internal/configuration/sources/env/wireguardselection.go vendored
View File

@@ -9,14 +9,14 @@ import (
"github.com/qdm12/govalid/port"
)
func (r *Reader) readWireguardSelection() (
func (s *Source) readWireguardSelection() (
selection settings.WireguardSelection, err error) {
selection.EndpointIP, err = r.readWireguardEndpointIP()
selection.EndpointIP, err = s.readWireguardEndpointIP()
if err != nil {
return selection, err
}
selection.EndpointPort, err = r.readWireguardCustomPort()
selection.EndpointPort, err = s.readWireguardCustomPort()
if err != nil {
return selection, err
}
@@ -28,29 +28,29 @@ func (r *Reader) readWireguardSelection() (
var ErrIPAddressParse = errors.New("cannot parse IP address")
func (r *Reader) readWireguardEndpointIP() (endpointIP net.IP, err error) {
key, s := r.getEnvWithRetro("VPN_ENDPOINT_IP", "WIREGUARD_ENDPOINT_IP")
if s == "" {
func (s *Source) readWireguardEndpointIP() (endpointIP net.IP, err error) {
key, value := s.getEnvWithRetro("VPN_ENDPOINT_IP", "WIREGUARD_ENDPOINT_IP")
if value == "" {
return nil, nil
}
endpointIP = net.ParseIP(s)
endpointIP = net.ParseIP(value)
if endpointIP == nil {
return nil, fmt.Errorf("environment variable %s: %w: %s",
key, ErrIPAddressParse, s)
key, ErrIPAddressParse, value)
}
return endpointIP, nil
}
func (r *Reader) readWireguardCustomPort() (customPort *uint16, err error) {
key, s := r.getEnvWithRetro("VPN_ENDPOINT_PORT", "WIREGUARD_ENDPOINT_PORT")
if s == "" {
func (s *Source) readWireguardCustomPort() (customPort *uint16, err error) {
key, value := s.getEnvWithRetro("VPN_ENDPOINT_PORT", "WIREGUARD_ENDPOINT_PORT")
if value == "" {
return nil, nil //nolint:nilnil
}
customPort = new(uint16)
*customPort, err = port.Validate(s)
*customPort, err = port.Validate(value)
if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", key, err)
}

2
internal/configuration/sources/files/health.go
View File

@@ -2,4 +2,4 @@ package files
import "github.com/qdm12/gluetun/internal/configuration/settings"
func (r *Reader) ReadHealth() (settings settings.Health, err error) { return settings, nil }
func (s *Source) ReadHealth() (settings settings.Health, err error) { return settings, nil }

2
internal/configuration/sources/files/openvpn.go
View File

@@ -14,7 +14,7 @@ const (
openVPNEncryptedKey = "/gluetun/openvpn_encrypted_key"
)
func (r *Reader) readOpenVPN() (settings settings.OpenVPN, err error) {
func (s *Source) readOpenVPN() (settings settings.OpenVPN, err error) {
settings.Key, err = readPEMFile(OpenVPNClientKeyPath)
if err != nil {
return settings, fmt.Errorf("client key: %w", err)

14
internal/configuration/sources/files/reader.go
View File

@@ -4,21 +4,21 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
type Reader struct{}
type Source struct{}
func New() *Reader {
return &Reader{}
func New() *Source {
return &Source{}
}
func (r *Reader) String() string { return "files" }
func (s *Source) String() string { return "files" }
func (r *Reader) Read() (settings settings.Settings, err error) {
settings.VPN, err = r.readVPN()
func (s *Source) Read() (settings settings.Settings, err error) {
settings.VPN, err = s.readVPN()
if err != nil {
return settings, err
}
settings.System, err = r.readSystem()
settings.System, err = s.readSystem()
if err != nil {
return settings, err
}

2
internal/configuration/sources/files/system.go
View File

@@ -4,7 +4,7 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readSystem() (system settings.System, err error) {
func (s *Source) readSystem() (system settings.System, err error) {
// TODO timezone from /etc/localtime
return system, nil
}

4
internal/configuration/sources/files/vpn.go
View File

@@ -6,8 +6,8 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
func (r *Reader) readVPN() (vpn settings.VPN, err error) {
vpn.OpenVPN, err = r.readOpenVPN()
func (s *Source) readVPN() (vpn settings.VPN, err error) {
vpn.OpenVPN, err = s.readOpenVPN()
if err != nil {
return vpn, fmt.Errorf("OpenVPN: %w", err)
}

26
internal/configuration/sources/merge/reader.go
View File

@@ -7,26 +7,26 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
type Source interface {
type ConfigSource interface {
Read() (settings settings.Settings, err error)
ReadHealth() (settings settings.Health, err error)
String() string
}
type Reader struct {
sources []Source
type Source struct {
sources []ConfigSource
}
func New(sources ...Source) *Reader {
return &Reader{
func New(sources ...ConfigSource) *Source {
return &Source{
sources: sources,
}
}
func (r *Reader) String() string {
sources := make([]string, len(r.sources))
for i := range r.sources {
sources[i] = r.sources[i].String()
func (s *Source) String() string {
sources := make([]string, len(s.sources))
for i := range s.sources {
sources[i] = s.sources[i].String()
}
return strings.Join(sources, ", ")
}
@@ -34,8 +34,8 @@ func (r *Reader) String() string {
// Read reads the settings for each source, merging unset fields
// with field set by the next source.
// It then set defaults to remaining unset fields.
func (r *Reader) Read() (settings settings.Settings, err error) {
for _, source := range r.sources {
func (s *Source) Read() (settings settings.Settings, err error) {
for _, source := range s.sources {
settingsFromSource, err := source.Read()
if err != nil {
return settings, fmt.Errorf("reading from %s: %w", source, err)
@@ -50,8 +50,8 @@ func (r *Reader) Read() (settings settings.Settings, err error) {
// with field set by the next source.
// It then set defaults to remaining unset fields, and validate
// all the fields.
func (r *Reader) ReadHealth() (settings settings.Health, err error) {
for _, source := range r.sources {
func (s *Source) ReadHealth() (settings settings.Health, err error) {
for _, source := range s.sources {
settingsFromSource, err := source.ReadHealth()
if err != nil {
return settings, fmt.Errorf("reading from %s: %w", source, err)

2
internal/configuration/sources/secrets/health.go
View File

@@ -2,4 +2,4 @@ package secrets
import "github.com/qdm12/gluetun/internal/configuration/settings"
func (r *Reader) ReadHealth() (settings settings.Health, err error) { return settings, nil }
func (s *Source) ReadHealth() (settings settings.Health, err error) { return settings, nil }

10
internal/configuration/sources/secrets/reader.go
View File

@@ -4,15 +4,15 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings"
)
type Reader struct{}
type Source struct{}
func New() *Reader {
return &Reader{}
func New() *Source {
return &Source{}
}
func (r *Reader) String() string { return "secret files" }
func (s *Source) String() string { return "secret files" }
func (r *Reader) Read() (settings settings.Settings, err error) {
func (s *Source) Read() (settings settings.Settings, err error) {
settings.VPN, err = readVPN()
if err != nil {
return settings, err