diff --git a/internal/configuration/sources/env/dns.go b/internal/configuration/sources/env/dns.go
index d166e6c7..bb48e891 100644
--- a/internal/configuration/sources/env/dns.go
+++ b/internal/configuration/sources/env/dns.go
@@ -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.")
 	}
diff --git a/internal/configuration/sources/env/dnsblacklist.go b/internal/configuration/sources/env/dnsblacklist.go
index b0d27030..752d8a9d 100644
--- a/internal/configuration/sources/env/dnsblacklist.go
+++ b/internal/configuration/sources/env/dnsblacklist.go
@@ -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
 	}
diff --git a/internal/configuration/sources/env/dot.go b/internal/configuration/sources/env/dot.go
index 273f9857..9626a60b 100644
--- a/internal/configuration/sources/env/dot.go
+++ b/internal/configuration/sources/env/dot.go
@@ -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
 	}
diff --git a/internal/configuration/sources/env/firewall.go b/internal/configuration/sources/env/firewall.go
index 45eafbe7..b93482a8 100644
--- a/internal/configuration/sources/env/firewall.go
+++ b/internal/configuration/sources/env/firewall.go
@@ -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 {
diff --git a/internal/configuration/sources/env/health.go b/internal/configuration/sources/env/health.go
index 0d322842..bad583a0 100644
--- a/internal/configuration/sources/env/health.go
+++ b/internal/configuration/sources/env/health.go
@@ -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)
 	}
diff --git a/internal/configuration/sources/env/httproxy.go b/internal/configuration/sources/env/httproxy.go
index 62cb6da0..2b138e8a 100644
--- a/internal/configuration/sources/env/httproxy.go
+++ b/internal/configuration/sources/env/httproxy.go
@@ -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)
 	}
diff --git a/internal/configuration/sources/env/openvpn.go b/internal/configuration/sources/env/openvpn.go
index 995e1e14..82e8c79c 100644
--- a/internal/configuration/sources/env/openvpn.go
+++ b/internal/configuration/sources/env/openvpn.go
@@ -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
 	}
diff --git a/internal/configuration/sources/env/openvpnselection.go b/internal/configuration/sources/env/openvpnselection.go
index f92321c2..aef7a18a 100644
--- a/internal/configuration/sources/env/openvpnselection.go
+++ b/internal/configuration/sources/env/openvpnselection.go
@@ -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)
 	}
diff --git a/internal/configuration/sources/env/portforward.go b/internal/configuration/sources/env/portforward.go
index ba19bca1..ce7b08eb 100644
--- a/internal/configuration/sources/env/portforward.go
+++ b/internal/configuration/sources/env/portforward.go
@@ -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 != "" {
diff --git a/internal/configuration/sources/env/provider.go b/internal/configuration/sources/env/provider.go
index 50f98ecb..98124f94 100644
--- a/internal/configuration/sources/env/provider.go
+++ b/internal/configuration/sources/env/provider.go
@@ -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)
 }
diff --git a/internal/configuration/sources/env/publicip.go b/internal/configuration/sources/env/publicip.go
index d0da77e5..a57b10d3 100644
--- a/internal/configuration/sources/env/publicip.go
+++ b/internal/configuration/sources/env/publicip.go
@@ -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
 }
diff --git a/internal/configuration/sources/env/reader.go b/internal/configuration/sources/env/reader.go
index 725534c6..3fc006fa 100644
--- a/internal/configuration/sources/env/reader.go
+++ b/internal/configuration/sources/env/reader.go
@@ -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
 		}
 	}
diff --git a/internal/configuration/sources/env/server.go b/internal/configuration/sources/env/server.go
index bed9ebce..a2fabf0a 100644
--- a/internal/configuration/sources/env/server.go
+++ b/internal/configuration/sources/env/server.go
@@ -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
 }
diff --git a/internal/configuration/sources/env/serverselection.go b/internal/configuration/sources/env/serverselection.go
index 5f47a354..6c1473d5 100644
--- a/internal/configuration/sources/env/serverselection.go
+++ b/internal/configuration/sources/env/serverselection.go
@@ -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)
diff --git a/internal/configuration/sources/env/shadowsocks.go b/internal/configuration/sources/env/shadowsocks.go
index 826eb376..a9bace58 100644
--- a/internal/configuration/sources/env/shadowsocks.go
+++ b/internal/configuration/sources/env/shadowsocks.go
@@ -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)
 }
diff --git a/internal/configuration/sources/env/system.go b/internal/configuration/sources/env/system.go
index 8085d6ee..78233d6a 100644
--- a/internal/configuration/sources/env/system.go
+++ b/internal/configuration/sources/env/system.go
@@ -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
 	}
diff --git a/internal/configuration/sources/env/system_test.go b/internal/configuration/sources/env/system_test.go
index 6ff2e19a..b004c7ad 100644
--- a/internal/configuration/sources/env/system_test.go
+++ b/internal/configuration/sources/env/system_test.go
@@ -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 {
diff --git a/internal/configuration/sources/env/vpn.go b/internal/configuration/sources/env/vpn.go
index e11cc31b..c4baafdf 100644
--- a/internal/configuration/sources/env/vpn.go
+++ b/internal/configuration/sources/env/vpn.go
@@ -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)
 	}
diff --git a/internal/configuration/sources/env/wireguard.go b/internal/configuration/sources/env/wireguard.go
index 5fd3917b..f9ab674b 100644
--- a/internal/configuration/sources/env/wireguard.go
+++ b/internal/configuration/sources/env/wireguard.go
@@ -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
 	}
diff --git a/internal/configuration/sources/env/wireguardselection.go b/internal/configuration/sources/env/wireguardselection.go
index 59c7f67e..e68b15f0 100644
--- a/internal/configuration/sources/env/wireguardselection.go
+++ b/internal/configuration/sources/env/wireguardselection.go
@@ -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)
 	}
diff --git a/internal/configuration/sources/files/health.go b/internal/configuration/sources/files/health.go
index aaf57b11..11950a4a 100644
--- a/internal/configuration/sources/files/health.go
+++ b/internal/configuration/sources/files/health.go
@@ -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 }
diff --git a/internal/configuration/sources/files/openvpn.go b/internal/configuration/sources/files/openvpn.go
index 6bfb3a0e..5c6b2fe9 100644
--- a/internal/configuration/sources/files/openvpn.go
+++ b/internal/configuration/sources/files/openvpn.go
@@ -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)
diff --git a/internal/configuration/sources/files/reader.go b/internal/configuration/sources/files/reader.go
index 34166ac4..ed593de3 100644
--- a/internal/configuration/sources/files/reader.go
+++ b/internal/configuration/sources/files/reader.go
@@ -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
 	}
diff --git a/internal/configuration/sources/files/system.go b/internal/configuration/sources/files/system.go
index e5be9bd9..8f01ba1b 100644
--- a/internal/configuration/sources/files/system.go
+++ b/internal/configuration/sources/files/system.go
@@ -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
 }
diff --git a/internal/configuration/sources/files/vpn.go b/internal/configuration/sources/files/vpn.go
index 8e3af796..48d8e156 100644
--- a/internal/configuration/sources/files/vpn.go
+++ b/internal/configuration/sources/files/vpn.go
@@ -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)
 	}
diff --git a/internal/configuration/sources/merge/reader.go b/internal/configuration/sources/merge/reader.go
index dc46f209..b28fc235 100644
--- a/internal/configuration/sources/merge/reader.go
+++ b/internal/configuration/sources/merge/reader.go
@@ -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)
diff --git a/internal/configuration/sources/secrets/health.go b/internal/configuration/sources/secrets/health.go
index ffc0aa5a..ae138270 100644
--- a/internal/configuration/sources/secrets/health.go
+++ b/internal/configuration/sources/secrets/health.go
@@ -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 }
diff --git a/internal/configuration/sources/secrets/reader.go b/internal/configuration/sources/secrets/reader.go
index e483f6b9..ed301366 100644
--- a/internal/configuration/sources/secrets/reader.go
+++ b/internal/configuration/sources/secrets/reader.go
@@ -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