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" "github.com/qdm12/gluetun/internal/configuration/settings"
) )
func (r *Reader) readDNS() (dns settings.DNS, err error) { func (s *Source) readDNS() (dns settings.DNS, err error) {
dns.ServerAddress, err = r.readDNSServerAddress() dns.ServerAddress, err = s.readDNSServerAddress()
if err != nil { if err != nil {
return dns, err 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) return dns, fmt.Errorf("environment variable DNS_KEEP_NAMESERVER: %w", err)
} }
dns.DoT, err = r.readDoT() dns.DoT, err = s.readDoT()
if err != nil { if err != nil {
return dns, fmt.Errorf("DoT settings: %w", err) return dns, fmt.Errorf("DoT settings: %w", err)
} }
@@ -26,22 +26,22 @@ func (r *Reader) readDNS() (dns settings.DNS, err error) {
return dns, nil return dns, nil
} }
func (r *Reader) readDNSServerAddress() (address net.IP, err error) { func (s *Source) readDNSServerAddress() (address net.IP, err error) {
key, s := r.getEnvWithRetro("DNS_ADDRESS", "DNS_PLAINTEXT_ADDRESS") key, value := s.getEnvWithRetro("DNS_ADDRESS", "DNS_PLAINTEXT_ADDRESS")
if s == "" { if value == "" {
return nil, nil return nil, nil
} }
address = net.ParseIP(s) address = net.ParseIP(value)
if address == nil { 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 // TODO remove in v4
if !address.Equal(net.IPv4(127, 0, 0, 1)) { //nolint:gomnd 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." + " 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" + " 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.") " 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" "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") blacklist.BlockMalicious, err = envToBoolPtr("BLOCK_MALICIOUS")
if err != nil { if err != nil {
return blacklist, fmt.Errorf("environment variable BLOCK_MALICIOUS: %w", err) return blacklist, fmt.Errorf("environment variable BLOCK_MALICIOUS: %w", err)
} }
blacklist.BlockSurveillance, err = r.readBlockSurveillance() blacklist.BlockSurveillance, err = s.readBlockSurveillance()
if err != nil { if err != nil {
return blacklist, err return blacklist, err
} }
@@ -36,8 +36,8 @@ func (r *Reader) readDNSBlacklist() (blacklist settings.DNSBlacklist, err error)
return blacklist, nil return blacklist, nil
} }
func (r *Reader) readBlockSurveillance() (blocked *bool, err error) { func (s *Source) readBlockSurveillance() (blocked *bool, err error) {
key, value := r.getEnvWithRetro("BLOCK_SURVEILLANCE", "BLOCK_NSA") key, value := s.getEnvWithRetro("BLOCK_SURVEILLANCE", "BLOCK_NSA")
if value == "" { if value == "" {
return nil, nil //nolint:nilnil 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" "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") dot.Enabled, err = envToBoolPtr("DOT")
if err != nil { if err != nil {
return dot, fmt.Errorf("environment variable DOT: %w", err) 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 return dot, err
} }
dot.Blacklist, err = r.readDNSBlacklist() dot.Blacklist, err = s.readDNSBlacklist()
if err != nil { if err != nil {
return dot, err 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" "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") vpnInputPortStrings := envToCSV("FIREWALL_VPN_INPUT_PORTS")
firewall.VPNInputPorts, err = stringsToPorts(vpnInputPortStrings) firewall.VPNInputPorts, err = stringsToPorts(vpnInputPortStrings)
if err != nil { 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) 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) outboundSubnetStrings := envToCSV(outboundSubnetsKey)
firewall.OutboundSubnets, err = stringsToIPNets(outboundSubnetStrings) firewall.OutboundSubnets, err = stringsToIPNets(outboundSubnetStrings)
if err != nil { 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" "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.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_VPN_DURATION_INITIAL",
"HEALTH_OPENVPN_DURATION_INITIAL") "HEALTH_OPENVPN_DURATION_INITIAL")
if err != nil { if err != nil {
return health, err return health, err
} }
health.VPN.Addition, err = r.readDurationWithRetro( health.VPN.Addition, err = s.readDurationWithRetro(
"HEALTH_VPN_DURATION_ADDITION", "HEALTH_VPN_DURATION_ADDITION",
"HEALTH_OPENVPN_DURATION_ADDITION") "HEALTH_OPENVPN_DURATION_ADDITION")
if err != nil { if err != nil {
@@ -28,14 +28,14 @@ func (r *Reader) ReadHealth() (health settings.Health, err error) {
return health, nil return health, nil
} }
func (r *Reader) readDurationWithRetro(envKey, retroEnvKey string) (d *time.Duration, err error) { func (s *Source) readDurationWithRetro(envKey, retroEnvKey string) (d *time.Duration, err error) {
envKey, s := r.getEnvWithRetro(envKey, retroEnvKey) envKey, value := s.getEnvWithRetro(envKey, retroEnvKey)
if s == "" { if value == "" {
return nil, nil //nolint:nilnil return nil, nil //nolint:nilnil
} }
d = new(time.Duration) d = new(time.Duration)
*d, err = time.ParseDuration(s) *d, err = time.ParseDuration(value)
if err != nil { if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", envKey, err) 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" "github.com/qdm12/govalid/binary"
) )
func (r *Reader) readHTTPProxy() (httpProxy settings.HTTPProxy, err error) { func (s *Source) readHTTPProxy() (httpProxy settings.HTTPProxy, err error) {
httpProxy.User = r.readHTTProxyUser() httpProxy.User = s.readHTTProxyUser()
httpProxy.Password = r.readHTTProxyPassword() httpProxy.Password = s.readHTTProxyPassword()
httpProxy.ListeningAddress = r.readHTTProxyListeningAddress() httpProxy.ListeningAddress = s.readHTTProxyListeningAddress()
httpProxy.Enabled, err = r.readHTTProxyEnabled() httpProxy.Enabled, err = s.readHTTProxyEnabled()
if err != nil { if err != nil {
return httpProxy, err 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) return httpProxy, fmt.Errorf("environment variable HTTPPROXY_STEALTH: %w", err)
} }
httpProxy.Log, err = r.readHTTProxyLog() httpProxy.Log, err = s.readHTTProxyLog()
if err != nil { if err != nil {
return httpProxy, err return httpProxy, err
} }
@@ -30,38 +30,38 @@ func (r *Reader) readHTTPProxy() (httpProxy settings.HTTPProxy, err error) {
return httpProxy, nil return httpProxy, nil
} }
func (r *Reader) readHTTProxyUser() (user *string) { func (s *Source) readHTTProxyUser() (user *string) {
_, s := r.getEnvWithRetro("HTTPPROXY_USER", "PROXY_USER", "TINYPROXY_USER") _, value := s.getEnvWithRetro("HTTPPROXY_USER", "PROXY_USER", "TINYPROXY_USER")
if s != "" { if value != "" {
return &s return &value
} }
return nil return nil
} }
func (r *Reader) readHTTProxyPassword() (user *string) { func (s *Source) readHTTProxyPassword() (user *string) {
_, s := r.getEnvWithRetro("HTTPPROXY_PASSWORD", "PROXY_PASSWORD", "TINYPROXY_PASSWORD") _, value := s.getEnvWithRetro("HTTPPROXY_PASSWORD", "PROXY_PASSWORD", "TINYPROXY_PASSWORD")
if s != "" { if value != "" {
return &s return &value
} }
return nil return nil
} }
func (r *Reader) readHTTProxyListeningAddress() (listeningAddress string) { func (s *Source) readHTTProxyListeningAddress() (listeningAddress string) {
key, value := r.getEnvWithRetro("HTTPPROXY_LISTENING_ADDRESS", "PROXY_PORT", "TINYPROXY_PORT", "HTTPPROXY_PORT") key, value := s.getEnvWithRetro("HTTPPROXY_LISTENING_ADDRESS", "PROXY_PORT", "TINYPROXY_PORT", "HTTPPROXY_PORT")
if key == "HTTPPROXY_LISTENING_ADDRESS" { if key == "HTTPPROXY_LISTENING_ADDRESS" {
return value return value
} }
return ":" + value return ":" + value
} }
func (r *Reader) readHTTProxyEnabled() (enabled *bool, err error) { func (s *Source) readHTTProxyEnabled() (enabled *bool, err error) {
key, s := r.getEnvWithRetro("HTTPPROXY", "PROXY", "TINYPROXY") key, value := s.getEnvWithRetro("HTTPPROXY", "PROXY", "TINYPROXY")
if s == "" { if value == "" {
return nil, nil //nolint:nilnil return nil, nil //nolint:nilnil
} }
enabled = new(bool) enabled = new(bool)
*enabled, err = binary.Validate(s) *enabled, err = binary.Validate(value)
if err != nil { if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", key, err) 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 return enabled, nil
} }
func (r *Reader) readHTTProxyLog() (enabled *bool, err error) { func (s *Source) readHTTProxyLog() (enabled *bool, err error) {
key, s := r.getEnvWithRetro("HTTPPROXY_LOG", "PROXY_LOG_LEVEL", "TINYPROXY_LOG") key, value := s.getEnvWithRetro("HTTPPROXY_LOG", "PROXY_LOG_LEVEL", "TINYPROXY_LOG")
if s == "" { if value == "" {
return nil, nil //nolint:nilnil return nil, nil //nolint:nilnil
} }
@@ -82,7 +82,7 @@ func (r *Reader) readHTTProxyLog() (enabled *bool, err error) {
} }
enabled = new(bool) enabled = new(bool)
*enabled, err = binary.Validate(s, binaryOptions...) *enabled, err = binary.Validate(value, binaryOptions...)
if err != nil { if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", key, err) 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" "github.com/qdm12/govalid/binary"
) )
func (r *Reader) readOpenVPN() ( func (s *Source) readOpenVPN() (
openVPN settings.OpenVPN, err error) { openVPN settings.OpenVPN, err error) {
defer func() { defer func() {
err = unsetEnvKeys([]string{"OPENVPN_KEY", "OPENVPN_CERT", err = unsetEnvKeys([]string{"OPENVPN_KEY", "OPENVPN_CERT",
@@ -16,14 +16,14 @@ func (r *Reader) readOpenVPN() (
}() }()
openVPN.Version = getCleanedEnv("OPENVPN_VERSION") openVPN.Version = getCleanedEnv("OPENVPN_VERSION")
openVPN.User = r.readOpenVPNUser() openVPN.User = s.readOpenVPNUser()
openVPN.Password = r.readOpenVPNPassword() openVPN.Password = s.readOpenVPNPassword()
confFile := getCleanedEnv("OPENVPN_CUSTOM_CONFIG") confFile := getCleanedEnv("OPENVPN_CUSTOM_CONFIG")
if confFile != "" { if confFile != "" {
openVPN.ConfFile = &confFile openVPN.ConfFile = &confFile
} }
ciphersKey, _ := r.getEnvWithRetro("OPENVPN_CIPHERS", "OPENVPN_CIPHER") ciphersKey, _ := s.getEnvWithRetro("OPENVPN_CIPHERS", "OPENVPN_CIPHER")
openVPN.Ciphers = envToCSV(ciphersKey) openVPN.Ciphers = envToCSV(ciphersKey)
auth := getCleanedEnv("OPENVPN_AUTH") auth := getCleanedEnv("OPENVPN_AUTH")
@@ -35,9 +35,9 @@ func (r *Reader) readOpenVPN() (
openVPN.Key = envToStringPtr("OPENVPN_KEY") openVPN.Key = envToStringPtr("OPENVPN_KEY")
openVPN.EncryptedKey = envToStringPtr("OPENVPN_ENCRYPTED_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") openVPN.IPv6, err = envToBoolPtr("OPENVPN_IPV6")
if err != nil { if err != nil {
@@ -49,9 +49,9 @@ func (r *Reader) readOpenVPN() (
return openVPN, fmt.Errorf("environment variable OPENVPN_MSSFIX: %w", err) 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 { if err != nil {
return openVPN, err return openVPN, err
} }
@@ -69,9 +69,9 @@ func (r *Reader) readOpenVPN() (
return openVPN, nil return openVPN, nil
} }
func (r *Reader) readOpenVPNUser() (user *string) { func (s *Source) readOpenVPNUser() (user *string) {
user = new(string) user = new(string)
_, *user = r.getEnvWithRetro("OPENVPN_USER", "USER") _, *user = s.getEnvWithRetro("OPENVPN_USER", "USER")
if *user == "" { if *user == "" {
return nil return nil
} }
@@ -81,9 +81,9 @@ func (r *Reader) readOpenVPNUser() (user *string) {
return user return user
} }
func (r *Reader) readOpenVPNPassword() (password *string) { func (s *Source) readOpenVPNPassword() (password *string) {
password = new(string) password = new(string)
_, *password = r.getEnvWithRetro("OPENVPN_PASSWORD", "PASSWORD") _, *password = s.getEnvWithRetro("OPENVPN_PASSWORD", "PASSWORD")
if *password == "" { if *password == "" {
return nil return nil
} }
@@ -91,7 +91,7 @@ func (r *Reader) readOpenVPNPassword() (password *string) {
return password return password
} }
func (r *Reader) readOpenVPNKeyPassphrase() (passphrase *string) { func (s *Source) readOpenVPNKeyPassphrase() (passphrase *string) {
passphrase = new(string) passphrase = new(string)
*passphrase = getCleanedEnv("OPENVPN_KEY_PASSPHRASE") *passphrase = getCleanedEnv("OPENVPN_KEY_PASSPHRASE")
if *passphrase == "" { if *passphrase == "" {
@@ -100,8 +100,8 @@ func (r *Reader) readOpenVPNKeyPassphrase() (passphrase *string) {
return passphrase return passphrase
} }
func (r *Reader) readPIAEncryptionPreset() (presetPtr *string) { func (s *Source) readPIAEncryptionPreset() (presetPtr *string) {
_, preset := r.getEnvWithRetro( _, preset := s.getEnvWithRetro(
"PRIVATE_INTERNET_ACCESS_OPENVPN_ENCRYPTION_PRESET", "PRIVATE_INTERNET_ACCESS_OPENVPN_ENCRYPTION_PRESET",
"PIA_ENCRYPTION", "ENCRYPTION") "PIA_ENCRYPTION", "ENCRYPTION")
if preset != "" { if preset != "" {
@@ -110,8 +110,8 @@ func (r *Reader) readPIAEncryptionPreset() (presetPtr *string) {
return nil return nil
} }
func (r *Reader) readOpenVPNProcessUser() (processUser string, err error) { func (s *Source) readOpenVPNProcessUser() (processUser string, err error) {
key, value := r.getEnvWithRetro("OPENVPN_PROCESS_USER", "OPENVPN_ROOT") key, value := s.getEnvWithRetro("OPENVPN_PROCESS_USER", "OPENVPN_ROOT")
if key == "OPENVPN_PROCESS_USER" { if key == "OPENVPN_PROCESS_USER" {
return value, nil return value, nil
} }

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

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

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

@@ -9,19 +9,19 @@ import (
"github.com/qdm12/gluetun/internal/constants/vpn" "github.com/qdm12/gluetun/internal/constants/vpn"
) )
func (r *Reader) readProvider(vpnType string) (provider settings.Provider, err error) { func (s *Source) readProvider(vpnType string) (provider settings.Provider, err error) {
provider.Name = r.readVPNServiceProvider(vpnType) provider.Name = s.readVPNServiceProvider(vpnType)
var providerName string var providerName string
if provider.Name != nil { if provider.Name != nil {
providerName = *provider.Name providerName = *provider.Name
} }
provider.ServerSelection, err = r.readServerSelection(providerName, vpnType) provider.ServerSelection, err = s.readServerSelection(providerName, vpnType)
if err != nil { if err != nil {
return provider, fmt.Errorf("server selection: %w", err) return provider, fmt.Errorf("server selection: %w", err)
} }
provider.PortForwarding, err = r.readPortForward() provider.PortForwarding, err = s.readPortForward()
if err != nil { if err != nil {
return provider, fmt.Errorf("port forwarding: %w", err) 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 return provider, nil
} }
func (r *Reader) readVPNServiceProvider(vpnType string) (vpnProviderPtr *string) { func (s *Source) readVPNServiceProvider(vpnType string) (vpnProviderPtr *string) {
_, s := r.getEnvWithRetro("VPN_SERVICE_PROVIDER", "VPNSP") _, value := s.getEnvWithRetro("VPN_SERVICE_PROVIDER", "VPNSP")
if s == "" { if value == "" {
if vpnType != vpn.Wireguard && getCleanedEnv("OPENVPN_CUSTOM_CONFIG") != "" { if vpnType != vpn.Wireguard && getCleanedEnv("OPENVPN_CUSTOM_CONFIG") != "" {
// retro compatibility // retro compatibility
return stringPtr(providers.Custom) return stringPtr(providers.Custom)
@@ -39,10 +39,10 @@ func (r *Reader) readVPNServiceProvider(vpnType string) (vpnProviderPtr *string)
return nil return nil
} }
s = strings.ToLower(s) value = strings.ToLower(value)
if s == "pia" { // retro compatibility if value == "pia" { // retro compatibility
return stringPtr(providers.PrivateInternetAccess) 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" "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() publicIP.Period, err = readPublicIPPeriod()
if err != nil { if err != nil {
return publicIP, err return publicIP, err
} }
publicIP.IPFilepath = r.readPublicIPFilepath() publicIP.IPFilepath = s.readPublicIPFilepath()
return publicIP, nil return publicIP, nil
} }
@@ -33,10 +33,10 @@ func readPublicIPPeriod() (period *time.Duration, err error) {
return period, nil return period, nil
} }
func (r *Reader) readPublicIPFilepath() (filepath *string) { func (s *Source) readPublicIPFilepath() (filepath *string) {
_, s := r.getEnvWithRetro("PUBLICIP_FILE", "IP_STATUS_FILE") _, value := s.getEnvWithRetro("PUBLICIP_FILE", "IP_STATUS_FILE")
if s != "" { if value != "" {
return &s return &value
} }
return nil return nil
} }

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

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

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

@@ -7,13 +7,13 @@ import (
"github.com/qdm12/govalid/binary" "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() controlServer.Log, err = readControlServerLog()
if err != nil { if err != nil {
return controlServer, err return controlServer, err
} }
controlServer.Address = r.readControlServerAddress() controlServer.Address = s.readControlServerAddress()
return controlServer, nil return controlServer, nil
} }
@@ -32,17 +32,17 @@ func readControlServerLog() (enabled *bool, err error) {
return &log, nil return &log, nil
} }
func (r *Reader) readControlServerAddress() (address *string) { func (s *Source) readControlServerAddress() (address *string) {
key, s := r.getEnvWithRetro("HTTP_CONTROL_SERVER_ADDRESS", "HTTP_CONTROL_SERVER_PORT") key, value := s.getEnvWithRetro("HTTP_CONTROL_SERVER_ADDRESS", "HTTP_CONTROL_SERVER_PORT")
if s == "" { if value == "" {
return nil return nil
} }
if key == "HTTP_CONTROL_SERVER_ADDRESS" { if key == "HTTP_CONTROL_SERVER_ADDRESS" {
return &s return &value
} }
address = new(string) address = new(string)
*address = ":" + s *address = ":" + value
return address 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") 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 settings.ServerSelection, err error) {
ss.VPN = vpnType ss.VPN = vpnType
ss.TargetIP, err = r.readOpenVPNTargetIP() ss.TargetIP, err = s.readOpenVPNTargetIP()
if err != nil { if err != nil {
return ss, err return ss, err
} }
countriesKey, _ := r.getEnvWithRetro("SERVER_COUNTRIES", "COUNTRY") countriesKey, _ := s.getEnvWithRetro("SERVER_COUNTRIES", "COUNTRY")
ss.Countries = envToCSV(countriesKey) ss.Countries = envToCSV(countriesKey)
if vpnProvider == providers.Cyberghost && len(ss.Countries) == 0 { if vpnProvider == providers.Cyberghost && len(ss.Countries) == 0 {
// Retro-compatibility for Cyberghost using the REGION variable // Retro-compatibility for Cyberghost using the REGION variable
ss.Countries = envToCSV("REGION") ss.Countries = envToCSV("REGION")
if len(ss.Countries) > 0 { 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) ss.Regions = envToCSV(regionsKey)
citiesKey, _ := r.getEnvWithRetro("SERVER_CITIES", "CITY") citiesKey, _ := s.getEnvWithRetro("SERVER_CITIES", "CITY")
ss.Cities = envToCSV(citiesKey) ss.Cities = envToCSV(citiesKey)
ss.ISPs = envToCSV("ISP") ss.ISPs = envToCSV("ISP")
hostnamesKey, _ := r.getEnvWithRetro("SERVER_HOSTNAMES", "SERVER_HOSTNAME") hostnamesKey, _ := s.getEnvWithRetro("SERVER_HOSTNAMES", "SERVER_HOSTNAME")
ss.Hostnames = envToCSV(hostnamesKey) ss.Hostnames = envToCSV(hostnamesKey)
serverNamesKey, _ := r.getEnvWithRetro("SERVER_NAMES", "SERVER_NAME") serverNamesKey, _ := s.getEnvWithRetro("SERVER_NAMES", "SERVER_NAME")
ss.Names = envToCSV(serverNamesKey) ss.Names = envToCSV(serverNamesKey)
if csv := getCleanedEnv("SERVER_NUMBER"); csv != "" { if csv := getCleanedEnv("SERVER_NUMBER"); csv != "" {
@@ -66,7 +66,7 @@ func (r *Reader) readServerSelection(vpnProvider, vpnType string) (
} }
// Mullvad only // Mullvad only
ss.OwnedOnly, err = r.readOwnedOnly() ss.OwnedOnly, err = s.readOwnedOnly()
if err != nil { if err != nil {
return ss, err return ss, err
} }
@@ -95,12 +95,12 @@ func (r *Reader) readServerSelection(vpnProvider, vpnType string) (
return ss, fmt.Errorf("environment variable STREAM_ONLY: %w", err) return ss, fmt.Errorf("environment variable STREAM_ONLY: %w", err)
} }
ss.OpenVPN, err = r.readOpenVPNSelection() ss.OpenVPN, err = s.readOpenVPNSelection()
if err != nil { if err != nil {
return ss, err return ss, err
} }
ss.Wireguard, err = r.readWireguardSelection() ss.Wireguard, err = s.readWireguardSelection()
if err != nil { if err != nil {
return ss, err return ss, err
} }
@@ -112,23 +112,23 @@ var (
ErrInvalidIP = errors.New("invalid IP address") ErrInvalidIP = errors.New("invalid IP address")
) )
func (r *Reader) readOpenVPNTargetIP() (ip net.IP, err error) { func (s *Source) readOpenVPNTargetIP() (ip net.IP, err error) {
envKey, s := r.getEnvWithRetro("VPN_ENDPOINT_IP", "OPENVPN_TARGET_IP") envKey, value := s.getEnvWithRetro("VPN_ENDPOINT_IP", "OPENVPN_TARGET_IP")
if s == "" { if value == "" {
return nil, nil return nil, nil
} }
ip = net.ParseIP(s) ip = net.ParseIP(value)
if ip == nil { if ip == nil {
return nil, fmt.Errorf("environment variable %s: %w: %s", return nil, fmt.Errorf("environment variable %s: %w: %s",
envKey, ErrInvalidIP, s) envKey, ErrInvalidIP, value)
} }
return ip, nil return ip, nil
} }
func (r *Reader) readOwnedOnly() (ownedOnly *bool, err error) { func (s *Source) readOwnedOnly() (ownedOnly *bool, err error) {
envKey, _ := r.getEnvWithRetro("OWNED_ONLY", "OWNED") envKey, _ := s.getEnvWithRetro("OWNED_ONLY", "OWNED")
ownedOnly, err = envToBoolPtr(envKey) ownedOnly, err = envToBoolPtr(envKey)
if err != nil { if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", envKey, err) 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" "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") shadowsocks.Enabled, err = envToBoolPtr("SHADOWSOCKS")
if err != nil { if err != nil {
return shadowsocks, fmt.Errorf("environment variable SHADOWSOCKS: %w", err) return shadowsocks, fmt.Errorf("environment variable SHADOWSOCKS: %w", err)
} }
shadowsocks.Address = r.readShadowsocksAddress() shadowsocks.Address = s.readShadowsocksAddress()
shadowsocks.LogAddresses, err = envToBoolPtr("SHADOWSOCKS_LOG") shadowsocks.LogAddresses, err = envToBoolPtr("SHADOWSOCKS_LOG")
if err != nil { if err != nil {
return shadowsocks, fmt.Errorf("environment variable SHADOWSOCKS_LOG: %w", err) return shadowsocks, fmt.Errorf("environment variable SHADOWSOCKS_LOG: %w", err)
} }
shadowsocks.CipherName = r.readShadowsocksCipher() shadowsocks.CipherName = s.readShadowsocksCipher()
shadowsocks.Password = envToStringPtr("SHADOWSOCKS_PASSWORD") shadowsocks.Password = envToStringPtr("SHADOWSOCKS_PASSWORD")
return shadowsocks, nil return shadowsocks, nil
} }
func (r *Reader) readShadowsocksAddress() (address string) { func (s *Source) readShadowsocksAddress() (address string) {
key, value := r.getEnvWithRetro("SHADOWSOCKS_LISTENING_ADDRESS", "SHADOWSOCKS_PORT") key, value := s.getEnvWithRetro("SHADOWSOCKS_LISTENING_ADDRESS", "SHADOWSOCKS_PORT")
if value == "" { if value == "" {
return "" return ""
} }
@@ -38,7 +38,7 @@ func (r *Reader) readShadowsocksAddress() (address string) {
return ":" + value return ":" + value
} }
func (r *Reader) readShadowsocksCipher() (cipher string) { func (s *Source) readShadowsocksCipher() (cipher string) {
_, cipher = r.getEnvWithRetro("SHADOWSOCKS_CIPHER", "SHADOWSOCKS_METHOD") _, cipher = s.getEnvWithRetro("SHADOWSOCKS_CIPHER", "SHADOWSOCKS_METHOD")
return strings.ToLower(cipher) 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") ErrSystemTimezoneNotValid = errors.New("timezone is not valid")
) )
func (r *Reader) readSystem() (system settings.System, err error) { func (s *Source) readSystem() (system settings.System, err error) {
system.PUID, err = r.readID("PUID", "UID") system.PUID, err = s.readID("PUID", "UID")
if err != nil { if err != nil {
return system, err return system, err
} }
system.PGID, err = r.readID("PGID", "GID") system.PGID, err = s.readID("PGID", "GID")
if err != nil { if err != nil {
return system, err 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") 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) { id *uint32, err error) {
idEnvKey, idString := r.getEnvWithRetro(key, retroKey) idEnvKey, idString := s.getEnvWithRetro(key, retroKey)
if idString == "" { if idString == "" {
return nil, nil //nolint:nilnil 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, key, testCase.keyValue)
setTestEnv(t, retroKey, testCase.retroValue) setTestEnv(t, retroKey, testCase.retroValue)
reader := &Reader{} source := &Source{}
id, err := reader.readID(key, retroKey) id, err := source.readID(key, retroKey)
assert.ErrorIs(t, err, testCase.errWrapped) assert.ErrorIs(t, err, testCase.errWrapped)
if err != nil { 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" "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.Type = strings.ToLower(getCleanedEnv("VPN_TYPE"))
vpn.Provider, err = r.readProvider(vpn.Type) vpn.Provider, err = s.readProvider(vpn.Type)
if err != nil { if err != nil {
return vpn, fmt.Errorf("VPN provider: %w", err) return vpn, fmt.Errorf("VPN provider: %w", err)
} }
vpn.OpenVPN, err = r.readOpenVPN() vpn.OpenVPN, err = s.readOpenVPN()
if err != nil { if err != nil {
return vpn, fmt.Errorf("OpenVPN: %w", err) return vpn, fmt.Errorf("OpenVPN: %w", err)
} }
vpn.Wireguard, err = r.readWireguard() vpn.Wireguard, err = s.readWireguard()
if err != nil { if err != nil {
return vpn, fmt.Errorf("wireguard: %w", err) 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" "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() { defer func() {
err = unsetEnvKeys([]string{"WIREGUARD_PRIVATE_KEY", "WIREGUARD_PRESHARED_KEY"}, err) err = unsetEnvKeys([]string{"WIREGUARD_PRIVATE_KEY", "WIREGUARD_PRESHARED_KEY"}, err)
}() }()
wireguard.PrivateKey = envToStringPtr("WIREGUARD_PRIVATE_KEY") wireguard.PrivateKey = envToStringPtr("WIREGUARD_PRIVATE_KEY")
wireguard.PreSharedKey = envToStringPtr("WIREGUARD_PRESHARED_KEY") wireguard.PreSharedKey = envToStringPtr("WIREGUARD_PRESHARED_KEY")
_, wireguard.Interface = r.getEnvWithRetro("VPN_INTERFACE", "WIREGUARD_INTERFACE") _, wireguard.Interface = s.getEnvWithRetro("VPN_INTERFACE", "WIREGUARD_INTERFACE")
wireguard.Addresses, err = r.readWireguardAddresses() wireguard.Addresses, err = s.readWireguardAddresses()
if err != nil { if err != nil {
return wireguard, err // already wrapped return wireguard, err // already wrapped
} }
return wireguard, nil return wireguard, nil
} }
func (r *Reader) readWireguardAddresses() (addresses []net.IPNet, err error) { func (s *Source) readWireguardAddresses() (addresses []net.IPNet, err error) {
key, addressesCSV := r.getEnvWithRetro("WIREGUARD_ADDRESSES", "WIREGUARD_ADDRESS") key, addressesCSV := s.getEnvWithRetro("WIREGUARD_ADDRESSES", "WIREGUARD_ADDRESS")
if addressesCSV == "" { if addressesCSV == "" {
return nil, nil return nil, nil
} }

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

@@ -9,14 +9,14 @@ import (
"github.com/qdm12/govalid/port" "github.com/qdm12/govalid/port"
) )
func (r *Reader) readWireguardSelection() ( func (s *Source) readWireguardSelection() (
selection settings.WireguardSelection, err error) { selection settings.WireguardSelection, err error) {
selection.EndpointIP, err = r.readWireguardEndpointIP() selection.EndpointIP, err = s.readWireguardEndpointIP()
if err != nil { if err != nil {
return selection, err return selection, err
} }
selection.EndpointPort, err = r.readWireguardCustomPort() selection.EndpointPort, err = s.readWireguardCustomPort()
if err != nil { if err != nil {
return selection, err return selection, err
} }
@@ -28,29 +28,29 @@ func (r *Reader) readWireguardSelection() (
var ErrIPAddressParse = errors.New("cannot parse IP address") var ErrIPAddressParse = errors.New("cannot parse IP address")
func (r *Reader) readWireguardEndpointIP() (endpointIP net.IP, err error) { func (s *Source) readWireguardEndpointIP() (endpointIP net.IP, err error) {
key, s := r.getEnvWithRetro("VPN_ENDPOINT_IP", "WIREGUARD_ENDPOINT_IP") key, value := s.getEnvWithRetro("VPN_ENDPOINT_IP", "WIREGUARD_ENDPOINT_IP")
if s == "" { if value == "" {
return nil, nil return nil, nil
} }
endpointIP = net.ParseIP(s) endpointIP = net.ParseIP(value)
if endpointIP == nil { if endpointIP == nil {
return nil, fmt.Errorf("environment variable %s: %w: %s", return nil, fmt.Errorf("environment variable %s: %w: %s",
key, ErrIPAddressParse, s) key, ErrIPAddressParse, value)
} }
return endpointIP, nil return endpointIP, nil
} }
func (r *Reader) readWireguardCustomPort() (customPort *uint16, err error) { func (s *Source) readWireguardCustomPort() (customPort *uint16, err error) {
key, s := r.getEnvWithRetro("VPN_ENDPOINT_PORT", "WIREGUARD_ENDPOINT_PORT") key, value := s.getEnvWithRetro("VPN_ENDPOINT_PORT", "WIREGUARD_ENDPOINT_PORT")
if s == "" { if value == "" {
return nil, nil //nolint:nilnil return nil, nil //nolint:nilnil
} }
customPort = new(uint16) customPort = new(uint16)
*customPort, err = port.Validate(s) *customPort, err = port.Validate(value)
if err != nil { if err != nil {
return nil, fmt.Errorf("environment variable %s: %w", key, err) 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" 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" 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) settings.Key, err = readPEMFile(OpenVPNClientKeyPath)
if err != nil { if err != nil {
return settings, fmt.Errorf("client key: %w", err) 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" "github.com/qdm12/gluetun/internal/configuration/settings"
) )
type Reader struct{} type Source struct{}
func New() *Reader { func New() *Source {
return &Reader{} 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) { func (s *Source) Read() (settings settings.Settings, err error) {
settings.VPN, err = r.readVPN() settings.VPN, err = s.readVPN()
if err != nil { if err != nil {
return settings, err return settings, err
} }
settings.System, err = r.readSystem() settings.System, err = s.readSystem()
if err != nil { if err != nil {
return settings, err return settings, err
} }

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

@@ -4,7 +4,7 @@ import (
"github.com/qdm12/gluetun/internal/configuration/settings" "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 // TODO timezone from /etc/localtime
return system, nil return system, nil
} }

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

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