From 39aa983771d89112862a131ee5a02badc67a20a0 Mon Sep 17 00:00:00 2001 From: "Quentin McGaw (desktop)" Date: Fri, 23 Jul 2021 02:34:15 +0000 Subject: [PATCH] Maint: upgrade golibs and env error wrapping --- go.mod | 2 +- go.sum | 7 +++++-- internal/configuration/cyberghost.go | 8 +++++--- internal/configuration/dns.go | 8 ++++---- internal/configuration/dnsblacklist.go | 10 +++++----- internal/configuration/fastestvpn.go | 6 ++++-- internal/configuration/firewall.go | 20 ++++++++++++++----- internal/configuration/health.go | 9 +++++---- internal/configuration/health_test.go | 8 ++++---- internal/configuration/hidemyass.go | 10 ++++++---- internal/configuration/httpproxy.go | 13 ++++++------ internal/configuration/ipvanish.go | 8 +++++--- internal/configuration/ipvanish_test.go | 10 +++++----- internal/configuration/ivpn.go | 8 +++++--- internal/configuration/ivpn_test.go | 10 +++++----- internal/configuration/mullvad.go | 13 ++++++------ internal/configuration/nordvpn.go | 6 +++--- internal/configuration/openvpn.go | 20 +++++++++---------- internal/configuration/privado.go | 10 ++++++---- .../configuration/privateinternetaccess.go | 15 +++++++------- internal/configuration/privatevpn.go | 8 +++++--- internal/configuration/protonvpn.go | 16 ++++++++------- internal/configuration/provider.go | 14 ++++++++----- internal/configuration/provider_test.go | 2 +- internal/configuration/publicip.go | 5 +++-- internal/configuration/purevpn.go | 10 ++++++---- internal/configuration/reader.go | 13 +++++------- internal/configuration/secrets.go | 11 ++++++---- internal/configuration/server.go | 5 +++-- internal/configuration/settings.go | 2 +- internal/configuration/shadowsocks.go | 13 +++++++----- internal/configuration/surfshark.go | 6 ++++-- internal/configuration/system.go | 7 ++++--- internal/configuration/torguard.go | 8 +++++--- internal/configuration/unbound.go | 12 +++++------ internal/configuration/updater.go | 3 ++- internal/configuration/vpnunlimited.go | 12 ++++++----- internal/configuration/vyprvpn.go | 4 +++- internal/configuration/windscribe.go | 7 ++++--- 39 files changed, 207 insertions(+), 152 deletions(-) diff --git a/go.mod b/go.mod index 6aead6a2..6d5ba049 100644 --- a/go.mod +++ b/go.mod @@ -6,7 +6,7 @@ require ( github.com/fatih/color v1.12.0 github.com/golang/mock v1.6.0 github.com/qdm12/dns v1.9.0 - github.com/qdm12/golibs v0.0.0-20210716185557-66793f4ddd80 + github.com/qdm12/golibs v0.0.0-20210721223530-ec1d3fe6dc99 github.com/qdm12/goshutdown v0.1.0 github.com/qdm12/gosplash v0.1.0 github.com/qdm12/ss-server v0.2.0 diff --git a/go.sum b/go.sum index d11d0be6..53b41ec6 100644 --- a/go.sum +++ b/go.sum @@ -66,8 +66,9 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN github.com/qdm12/dns v1.9.0 h1:p4g/BfbpQ+gJRpQdklDAnybkjds+OuenF0wEGoZ8/AI= github.com/qdm12/dns v1.9.0/go.mod h1:fqZoDf3VzddnKBMNI/OzZUp5H4dO0VBw1fp4qPkolOg= github.com/qdm12/golibs v0.0.0-20210603202746-e5494e9c2ebb/go.mod h1:15RBzkun0i8XB7ADIoLJWp9ITRgsz3LroEI2FiOXLRg= -github.com/qdm12/golibs v0.0.0-20210716185557-66793f4ddd80 h1:rvH2MSs8RXEfuXivzoYCim6tRNPzdqjBzqJq8w4Tc0k= github.com/qdm12/golibs v0.0.0-20210716185557-66793f4ddd80/go.mod h1:15RBzkun0i8XB7ADIoLJWp9ITRgsz3LroEI2FiOXLRg= +github.com/qdm12/golibs v0.0.0-20210721223530-ec1d3fe6dc99 h1:2OKHAR0SK8BtTtWCRNoSn58eh+iVDA3Cwq4i2CnD3i4= +github.com/qdm12/golibs v0.0.0-20210721223530-ec1d3fe6dc99/go.mod h1:6aRbg4Z/bTbm9JfxsGXfWKHi7zsOvPfUTK1S5HuAFKg= github.com/qdm12/goshutdown v0.1.0 h1:lmwnygdXtnr2pa6VqfR/bm8077/BnBef1+7CP96B7Sw= github.com/qdm12/goshutdown v0.1.0/go.mod h1:/LP3MWLqI+wGH/ijfaUG+RHzBbKXIiVKnrg5vXOCf6Q= github.com/qdm12/gosplash v0.1.0 h1:Sfl+zIjFZFP7b0iqf2l5UkmEY97XBnaKkH3FNY6Gf7g= @@ -105,8 +106,9 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a h1:kr2P4QFmQr29mSLA43kwrOcgcReGTfbE9N577tCTuBc= golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= +golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 h1:/UOmuWzQfxxo9UtlXMwuQU8CMgg1eZXqTRwkSQJWKOI= +golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= @@ -136,6 +138,7 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= diff --git a/internal/configuration/cyberghost.go b/internal/configuration/cyberghost.go index 941b5dad..8131aec7 100644 --- a/internal/configuration/cyberghost.go +++ b/internal/configuration/cyberghost.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" "github.com/qdm12/golibs/params" ) @@ -53,17 +55,17 @@ func (settings *Provider) readCyberghost(r reader) (err error) { settings.ServerSelection.Group, err = r.env.Inside("CYBERGHOST_GROUP", constants.CyberghostGroupChoices(), params.Default("Premium UDP Europe")) if err != nil { - return err + return fmt.Errorf("environment variable CYBERGHOST_GROUP: %w", err) } settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.CyberghostRegionChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.CyberghostHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/dns.go b/internal/configuration/dns.go index 87fc37af..a6b353ab 100644 --- a/internal/configuration/dns.go +++ b/internal/configuration/dns.go @@ -68,7 +68,7 @@ var ( func (settings *DNS) read(r reader) (err error) { settings.Enabled, err = r.env.OnOff("DOT", params.Default("on")) if err != nil { - return err + return fmt.Errorf("environment variable DOT: %w", err) } // Plain DNS settings @@ -77,7 +77,7 @@ func (settings *DNS) read(r reader) (err error) { } settings.KeepNameserver, err = r.env.OnOff("DNS_KEEP_NAMESERVER", params.Default("off")) if err != nil { - return err + return fmt.Errorf("environment variable DNS_KEEP_NAMESERVER: %w", err) } // DNS over TLS external settings @@ -87,7 +87,7 @@ func (settings *DNS) read(r reader) (err error) { settings.UpdatePeriod, err = r.env.Duration("DNS_UPDATE_PERIOD", params.Default("24h")) if err != nil { - return err + return fmt.Errorf("environment variable DNS_UPDATE_PERIOD: %w", err) } // Unbound settings @@ -105,7 +105,7 @@ var ( func (settings *DNS) readDNSPlaintext(env params.Env) error { s, err := env.Get("DNS_PLAINTEXT_ADDRESS", params.Default("1.1.1.1")) if err != nil { - return err + return fmt.Errorf("environment variable DNS_PLAINTEXT_ADDRESS: %w", err) } settings.PlaintextAddress = net.ParseIP(s) diff --git a/internal/configuration/dnsblacklist.go b/internal/configuration/dnsblacklist.go index 01056aad..83eded49 100644 --- a/internal/configuration/dnsblacklist.go +++ b/internal/configuration/dnsblacklist.go @@ -11,18 +11,18 @@ import ( func (settings *DNS) readBlacklistBuilding(r reader) (err error) { settings.BlacklistBuild.BlockMalicious, err = r.env.OnOff("BLOCK_MALICIOUS", params.Default("on")) if err != nil { - return err + return fmt.Errorf("environment variable BLOCK_MALICIOUS: %w", err) } settings.BlacklistBuild.BlockSurveillance, err = r.env.OnOff("BLOCK_SURVEILLANCE", params.Default("on"), params.RetroKeys([]string{"BLOCK_NSA"}, r.onRetroActive)) if err != nil { - return err + return fmt.Errorf("environment variable BLOCK_SURVEILLANCE (or BLOCK_NSA): %w", err) } settings.BlacklistBuild.BlockAds, err = r.env.OnOff("BLOCK_ADS", params.Default("off")) if err != nil { - return err + return fmt.Errorf("environment variable BLOCK_ADS: %w", err) } if err := settings.readPrivateAddresses(r.env); err != nil { @@ -39,7 +39,7 @@ var ( func (settings *DNS) readPrivateAddresses(env params.Env) (err error) { privateAddresses, err := env.CSV("DOT_PRIVATE_ADDRESS") if err != nil { - return err + return fmt.Errorf("environment variable DOT_PRIVATE_ADDRESS: %w", err) } else if len(privateAddresses) == 0 { return nil } @@ -72,7 +72,7 @@ func (settings *DNS) readPrivateAddresses(env params.Env) (err error) { func (settings *DNS) readBlacklistUnblockedHostnames(r reader) (err error) { hostnames, err := r.env.CSV("UNBLOCK") if err != nil { - return err + return fmt.Errorf("environment variable UNBLOCK: %w", err) } else if len(hostnames) == 0 { return nil } diff --git a/internal/configuration/fastestvpn.go b/internal/configuration/fastestvpn.go index 5bd67cf1..d53cf3d9 100644 --- a/internal/configuration/fastestvpn.go +++ b/internal/configuration/fastestvpn.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -31,12 +33,12 @@ func (settings *Provider) readFastestvpn(r reader) (err error) { settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.FastestvpnHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.FastestvpnCountriesChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } return nil diff --git a/internal/configuration/firewall.go b/internal/configuration/firewall.go index 831a5189..222a3f18 100644 --- a/internal/configuration/firewall.go +++ b/internal/configuration/firewall.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "net" "strings" @@ -53,12 +54,12 @@ func (settings *Firewall) lines() (lines []string) { func (settings *Firewall) read(r reader) (err error) { settings.Enabled, err = r.env.OnOff("FIREWALL", params.Default("on")) if err != nil { - return err + return fmt.Errorf("environment variable FIREWALL: %w", err) } settings.Debug, err = r.env.OnOff("FIREWALL_DEBUG", params.Default("off")) if err != nil { - return err + return fmt.Errorf("environment variable FIREWALL_DEBUG: %w", err) } if err := settings.readVPNInputPorts(r.env); err != nil { @@ -74,16 +75,25 @@ func (settings *Firewall) read(r reader) (err error) { func (settings *Firewall) readVPNInputPorts(env params.Env) (err error) { settings.VPNInputPorts, err = readCSVPorts(env, "FIREWALL_VPN_INPUT_PORTS") - return err + if err != nil { + return fmt.Errorf("environment variable FIREWALL_VPN_INPUT_PORTS: %w", err) + } + return nil } func (settings *Firewall) readInputPorts(env params.Env) (err error) { settings.InputPorts, err = readCSVPorts(env, "FIREWALL_INPUT_PORTS") - return err + if err != nil { + return fmt.Errorf("environment variable FIREWALL_INPUT_PORTS: %w", err) + } + return nil } func (settings *Firewall) readOutboundSubnets(r reader) (err error) { retroOption := params.RetroKeys([]string{"EXTRA_SUBNETS"}, r.onRetroActive) settings.OutboundSubnets, err = readCSVIPNets(r.env, "FIREWALL_OUTBOUND_SUBNETS", retroOption) - return err + if err != nil { + return fmt.Errorf("environment variable FIREWALL_OUTBOUND_SUBNETS: %w", err) + } + return nil } diff --git a/internal/configuration/health.go b/internal/configuration/health.go index 2af20114..d54dbac0 100644 --- a/internal/configuration/health.go +++ b/internal/configuration/health.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strings" "github.com/qdm12/golibs/logging" @@ -42,20 +43,20 @@ func (settings *Health) read(r reader) (err error) { settings.ServerAddress, warning, err = r.env.ListeningAddress( "HEALTH_SERVER_ADDRESS", params.Default("127.0.0.1:9999")) if warning != "" { - r.logger.Warn("health server address: " + warning) + r.logger.Warn("environment variable HEALTH_SERVER_ADDRESS: " + warning) } if err != nil { - return err + return fmt.Errorf("environment variable HEALTH_SERVER_ADDRESS: %w", err) } settings.OpenVPN.Initial, err = r.env.Duration("HEALTH_OPENVPN_DURATION_INITIAL", params.Default("6s")) if err != nil { - return err + return fmt.Errorf("environment variable HEALTH_OPENVPN_DURATION_INITIAL: %w", err) } settings.OpenVPN.Addition, err = r.env.Duration("HEALTH_OPENVPN_DURATION_ADDITION", params.Default("5s")) if err != nil { - return err + return fmt.Errorf("environment variable HEALTH_OPENVPN_DURATION_ADDITION: %w", err) } return nil diff --git a/internal/configuration/health_test.go b/internal/configuration/health_test.go index 9a1add46..264ea9ba 100644 --- a/internal/configuration/health_test.go +++ b/internal/configuration/health_test.go @@ -105,7 +105,7 @@ func Test_Health_read(t *testing.T) { expected: Health{ ServerAddress: "127.0.0.1:9999", }, - err: errDummy, + err: errors.New("environment variable HEALTH_SERVER_ADDRESS: dummy"), }, "initial error": { openvpnInitialDuration: time.Second, @@ -116,7 +116,7 @@ func Test_Health_read(t *testing.T) { Initial: time.Second, }, }, - err: errDummy, + err: errors.New("environment variable HEALTH_OPENVPN_DURATION_INITIAL: dummy"), }, "addition error": { openvpnInitialDuration: time.Second, @@ -128,7 +128,7 @@ func Test_Health_read(t *testing.T) { Addition: time.Minute, }, }, - err: errDummy, + err: errors.New("environment variable HEALTH_OPENVPN_DURATION_ADDITION: dummy"), }, } @@ -146,7 +146,7 @@ func Test_Health_read(t *testing.T) { Return(testCase.serverAddress, testCase.serverAddressWarning, testCase.serverAddressErr) if testCase.serverAddressWarning != "" { - logger.EXPECT().Warn("health server address: " + testCase.serverAddressWarning) + logger.EXPECT().Warn("environment variable HEALTH_SERVER_ADDRESS: " + testCase.serverAddressWarning) } if testCase.serverAddressErr == nil { diff --git a/internal/configuration/hidemyass.go b/internal/configuration/hidemyass.go index e1065d0a..e0e211c5 100644 --- a/internal/configuration/hidemyass.go +++ b/internal/configuration/hidemyass.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -39,22 +41,22 @@ func (settings *Provider) readHideMyAss(r reader) (err error) { settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.HideMyAssCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.HideMyAssCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.HideMyAssCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.HideMyAssHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/httpproxy.go b/internal/configuration/httpproxy.go index 7502f51b..da3ef2a1 100644 --- a/internal/configuration/httpproxy.go +++ b/internal/configuration/httpproxy.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strconv" "strings" @@ -49,24 +50,24 @@ func (settings *HTTPProxy) read(r reader) (err error) { settings.Enabled, err = r.env.OnOff("HTTPPROXY", params.Default("off"), params.RetroKeys([]string{"TINYPROXY", "PROXY"}, r.onRetroActive)) if err != nil { - return err + return fmt.Errorf("environment variable HTTPPROXY (or TINYPROXY, PROXY): %w", err) } settings.User, err = r.getFromEnvOrSecretFile("HTTPPROXY_USER", false, // compulsory []string{"TINYPROXY_USER", "PROXY_USER"}) if err != nil { - return err + return fmt.Errorf("environment variable HTTPPROXY_USER (or TINYPROXY_USER, PROXY_USER): %w", err) } settings.Password, err = r.getFromEnvOrSecretFile("HTTPPROXY_PASSWORD", false, []string{"TINYPROXY_PASSWORD", "PROXY_PASSWORD"}) if err != nil { - return err + return fmt.Errorf("environment variable HTTPPROXY_PASSWORD (or TINYPROXY_PASSWORD, PROXY_PASSWORD): %w", err) } settings.Stealth, err = r.env.OnOff("HTTPPROXY_STEALTH", params.Default("off")) if err != nil { - return err + return fmt.Errorf("environment variable HTTPPROXY_STEALTH: %w", err) } if err := settings.readLog(r); err != nil { @@ -80,7 +81,7 @@ func (settings *HTTPProxy) read(r reader) (err error) { r.logger.Warn(warning) } if err != nil { - return err + return fmt.Errorf("environment variable HTTPPROXY_PORT (or TINYPROXY_PORT, PROXY_PORT): %w", err) } return nil @@ -90,7 +91,7 @@ func (settings *HTTPProxy) readLog(r reader) error { s, err := r.env.Get("HTTPPROXY_LOG", params.RetroKeys([]string{"PROXY_LOG_LEVEL", "TINYPROXY_LOG"}, r.onRetroActive)) if err != nil { - return err + return fmt.Errorf("environment variable HTTPPROXY_LOG (or TINYPROXY_LOG, PROXY_LOG_LEVEL): %w", err) } switch strings.ToLower(s) { diff --git a/internal/configuration/ipvanish.go b/internal/configuration/ipvanish.go index 210bb1d5..c33e251e 100644 --- a/internal/configuration/ipvanish.go +++ b/internal/configuration/ipvanish.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -35,17 +37,17 @@ func (settings *Provider) readIpvanish(r reader) (err error) { settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.IpvanishCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.IpvanishCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.IpvanishHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/ipvanish_test.go b/internal/configuration/ipvanish_test.go index cb982b02..e3d9ffe4 100644 --- a/internal/configuration/ipvanish_test.go +++ b/internal/configuration/ipvanish_test.go @@ -78,7 +78,7 @@ func Test_Provider_readIpvanish(t *testing.T) { settings: Provider{ Name: constants.Ipvanish, }, - err: errDummy, + err: errors.New("environment variable PROTOCOL: dummy test error"), }, "target IP error": { protocol: singleStringCall{call: true}, @@ -86,7 +86,7 @@ func Test_Provider_readIpvanish(t *testing.T) { settings: Provider{ Name: constants.Ipvanish, }, - err: errDummy, + err: errors.New("environment variable OPENVPN_TARGET_IP: dummy test error"), }, "countries error": { protocol: singleStringCall{call: true}, @@ -95,7 +95,7 @@ func Test_Provider_readIpvanish(t *testing.T) { settings: Provider{ Name: constants.Ipvanish, }, - err: errDummy, + err: errors.New("environment variable COUNTRY: dummy test error"), }, "cities error": { protocol: singleStringCall{call: true}, @@ -105,7 +105,7 @@ func Test_Provider_readIpvanish(t *testing.T) { settings: Provider{ Name: constants.Ipvanish, }, - err: errDummy, + err: errors.New("environment variable CITY: dummy test error"), }, "hostnames error": { protocol: singleStringCall{call: true}, @@ -116,7 +116,7 @@ func Test_Provider_readIpvanish(t *testing.T) { settings: Provider{ Name: constants.Ipvanish, }, - err: errDummy, + err: errors.New("environment variable SERVER_HOSTNAME: dummy test error"), }, "default settings": { protocol: singleStringCall{call: true}, diff --git a/internal/configuration/ivpn.go b/internal/configuration/ivpn.go index fef2cb6b..0f7f6dcb 100644 --- a/internal/configuration/ivpn.go +++ b/internal/configuration/ivpn.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -35,17 +37,17 @@ func (settings *Provider) readIvpn(r reader) (err error) { settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.IvpnCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.IvpnCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.IvpnHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/ivpn_test.go b/internal/configuration/ivpn_test.go index db702ed2..54e29388 100644 --- a/internal/configuration/ivpn_test.go +++ b/internal/configuration/ivpn_test.go @@ -78,7 +78,7 @@ func Test_Provider_readIvpn(t *testing.T) { settings: Provider{ Name: constants.Ivpn, }, - err: errDummy, + err: errors.New("environment variable PROTOCOL: dummy test error"), }, "target IP error": { protocol: singleStringCall{call: true}, @@ -86,7 +86,7 @@ func Test_Provider_readIvpn(t *testing.T) { settings: Provider{ Name: constants.Ivpn, }, - err: errDummy, + err: errors.New("environment variable OPENVPN_TARGET_IP: dummy test error"), }, "countries error": { protocol: singleStringCall{call: true}, @@ -95,7 +95,7 @@ func Test_Provider_readIvpn(t *testing.T) { settings: Provider{ Name: constants.Ivpn, }, - err: errDummy, + err: errors.New("environment variable COUNTRY: dummy test error"), }, "cities error": { protocol: singleStringCall{call: true}, @@ -105,7 +105,7 @@ func Test_Provider_readIvpn(t *testing.T) { settings: Provider{ Name: constants.Ivpn, }, - err: errDummy, + err: errors.New("environment variable CITY: dummy test error"), }, "hostnames error": { protocol: singleStringCall{call: true}, @@ -116,7 +116,7 @@ func Test_Provider_readIvpn(t *testing.T) { settings: Provider{ Name: constants.Ivpn, }, - err: errDummy, + err: errors.New("environment variable SERVER_HOSTNAME: dummy test error"), }, "default settings": { protocol: singleStringCall{call: true}, diff --git a/internal/configuration/mullvad.go b/internal/configuration/mullvad.go index 906b4fe4..b93a32e0 100644 --- a/internal/configuration/mullvad.go +++ b/internal/configuration/mullvad.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strconv" "github.com/qdm12/gluetun/internal/constants" @@ -50,22 +51,22 @@ func (settings *Provider) readMullvad(r reader) (err error) { settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.MullvadCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.MullvadCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.MullvadHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } settings.ServerSelection.ISPs, err = r.env.CSVInside("ISP", constants.MullvadISPChoices()) if err != nil { - return err + return fmt.Errorf("environment variable ISP: %w", err) } settings.ServerSelection.CustomPort, err = readCustomPort(r.env, settings.ServerSelection.TCP, @@ -76,12 +77,12 @@ func (settings *Provider) readMullvad(r reader) (err error) { settings.ServerSelection.Owned, err = r.env.YesNo("OWNED", params.Default("no")) if err != nil { - return err + return fmt.Errorf("environment variable OWNED: %w", err) } settings.ExtraConfigOptions.OpenVPNIPv6, err = r.env.OnOff("OPENVPN_IPV6", params.Default("off")) if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_IPV6: %w", err) } return nil diff --git a/internal/configuration/nordvpn.go b/internal/configuration/nordvpn.go index 79ed0409..d7ef5721 100644 --- a/internal/configuration/nordvpn.go +++ b/internal/configuration/nordvpn.go @@ -47,17 +47,17 @@ func (settings *Provider) readNordvpn(r reader) (err error) { settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.NordvpnRegionChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.NordvpnHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } settings.ServerSelection.Names, err = r.env.CSVInside("SERVER_NAME", constants.NordvpnHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_NAME: %w", err) } settings.ServerSelection.Numbers, err = readNordVPNServerNumbers(r.env) diff --git a/internal/configuration/openvpn.go b/internal/configuration/openvpn.go index 011a83ae..9f365d47 100644 --- a/internal/configuration/openvpn.go +++ b/internal/configuration/openvpn.go @@ -78,7 +78,7 @@ func (settings *OpenVPN) read(r reader) (err error) { "purevpn", "surfshark", "torguard", constants.VPNUnlimited, "vyprvpn", "windscribe"}, params.Default("private internet access")) if err != nil { - return err + return fmt.Errorf("environment variable VPNSP: %w", err) } if vpnsp == "pia" { // retro compatibility vpnsp = "private internet access" @@ -88,7 +88,7 @@ func (settings *OpenVPN) read(r reader) (err error) { settings.Config, err = r.env.Get("OPENVPN_CUSTOM_CONFIG", params.CaseSensitiveValue()) if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_CUSTOM_CONFIG: %w", err) } customConfig := settings.Config != "" @@ -100,7 +100,7 @@ func (settings *OpenVPN) read(r reader) (err error) { settings.User, err = r.getFromEnvOrSecretFile("OPENVPN_USER", credentialsRequired, []string{"USER"}) if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_USER: %w", err) } // Remove spaces in user ID to simplify user's life, thanks @JeordyR settings.User = strings.ReplaceAll(settings.User, " ", "") @@ -117,18 +117,18 @@ func (settings *OpenVPN) read(r reader) (err error) { settings.Version, err = r.env.Inside("OPENVPN_VERSION", []string{constants.Openvpn24, constants.Openvpn25}, params.Default(constants.Openvpn25)) if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_VERSION: %w", err) } settings.Verbosity, err = r.env.IntRange("OPENVPN_VERBOSITY", 0, 6, params.Default("1")) //nolint:gomnd if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_VERBOSITY: %w", err) } settings.Flags = []string{} flagsStr, err := r.env.Get("OPENVPN_FLAGS") if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_FLAGS: %w", err) } if flagsStr != "" { settings.Flags = strings.Fields(flagsStr) @@ -136,23 +136,23 @@ func (settings *OpenVPN) read(r reader) (err error) { settings.Root, err = r.env.YesNo("OPENVPN_ROOT", params.Default("yes")) if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_ROOT: %w", err) } settings.Cipher, err = r.env.Get("OPENVPN_CIPHER") if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_CIPHER: %w", err) } settings.Auth, err = r.env.Get("OPENVPN_AUTH") if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_AUTH: %w", err) } const maxMSSFix = 10000 mssFix, err := r.env.IntRange("OPENVPN_MSSFIX", 0, maxMSSFix, params.Default("0")) if err != nil { - return err + return fmt.Errorf("environment variable OPENVPN_MSSFIX: %w", err) } settings.MSSFix = uint16(mssFix) return settings.readProvider(r) diff --git a/internal/configuration/privado.go b/internal/configuration/privado.go index 67b44cd9..231d1af7 100644 --- a/internal/configuration/privado.go +++ b/internal/configuration/privado.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -39,22 +41,22 @@ func (settings *Provider) readPrivado(r reader) (err error) { settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PrivadoCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PrivadoRegionChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PrivadoCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PrivadoHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/privateinternetaccess.go b/internal/configuration/privateinternetaccess.go index d9c9df77..4c6bcf09 100644 --- a/internal/configuration/privateinternetaccess.go +++ b/internal/configuration/privateinternetaccess.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strconv" "github.com/qdm12/gluetun/internal/constants" @@ -55,41 +56,41 @@ func (settings *Provider) readPrivateInternetAccess(r reader) (err error) { params.Default(constants.PIACertificateStrong), ) if err != nil { - return err + return fmt.Errorf("environment variable PIA_ENCRYPTION: %w", err) } settings.ServerSelection.EncryptionPreset = encryptionPreset settings.ExtraConfigOptions.EncryptionPreset = encryptionPreset settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PIAGeoChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PIAHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_NAME", constants.PIANameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_NAME: %w", err) } settings.ServerSelection.CustomPort, err = readPortOrZero(r.env, "PORT") if err != nil { - return err + return fmt.Errorf("environment variable PORT: %w", err) } settings.PortForwarding.Enabled, err = r.env.OnOff("PORT_FORWARDING", params.Default("off")) if err != nil { - return err + return fmt.Errorf("environment variable PORT_FORWARDING: %w", err) } if settings.PortForwarding.Enabled { settings.PortForwarding.Filepath, err = r.env.Path("PORT_FORWARDING_STATUS_FILE", params.Default("/tmp/gluetun/forwarded_port"), params.CaseSensitiveValue()) if err != nil { - return err + return fmt.Errorf("environment variable PORT_FORWARDING_STATUS_FILE: %w", err) } } diff --git a/internal/configuration/privatevpn.go b/internal/configuration/privatevpn.go index a980e3dd..37c01874 100644 --- a/internal/configuration/privatevpn.go +++ b/internal/configuration/privatevpn.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -35,17 +37,17 @@ func (settings *Provider) readPrivatevpn(r reader) (err error) { settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PrivatevpnCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PrivatevpnCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PrivatevpnHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/protonvpn.go b/internal/configuration/protonvpn.go index f6236b85..1812d02d 100644 --- a/internal/configuration/protonvpn.go +++ b/internal/configuration/protonvpn.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" "github.com/qdm12/golibs/params" ) @@ -48,37 +50,37 @@ func (settings *Provider) readProtonvpn(r reader) (err error) { settings.ServerSelection.CustomPort, err = readPortOrZero(r.env, "PORT") if err != nil { - return err + return fmt.Errorf("environment variable PORT: %w", err) } settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.ProtonvpnCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.ProtonvpnRegionChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.ProtonvpnCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Names, err = r.env.CSVInside("SERVER_NAME", constants.ProtonvpnNameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_NAME: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.ProtonvpnHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } settings.ServerSelection.FreeOnly, err = r.env.YesNo("FREE_ONLY", params.Default("no")) if err != nil { - return err + return fmt.Errorf("environment variable FREE_ONLY: %w", err) } return nil diff --git a/internal/configuration/provider.go b/internal/configuration/provider.go index 9e3232d6..c70eb8a7 100644 --- a/internal/configuration/provider.go +++ b/internal/configuration/provider.go @@ -83,7 +83,7 @@ func commaJoin(slice []string) string { func readProtocol(env params.Env) (tcp bool, err error) { protocol, err := env.Inside("PROTOCOL", []string{constants.TCP, constants.UDP}, params.Default(constants.UDP)) if err != nil { - return false, err + return false, fmt.Errorf("environment variable PROTOCOL: %w", err) } return protocol == constants.TCP, nil } @@ -96,14 +96,18 @@ func protoToString(tcp bool) string { } func readTargetIP(env params.Env) (targetIP net.IP, err error) { - return readIP(env, "OPENVPN_TARGET_IP") + targetIP, err = readIP(env, "OPENVPN_TARGET_IP") + if err != nil { + return nil, fmt.Errorf("environment variable OPENVPN_TARGET_IP: %w", err) + } + return targetIP, nil } func readCustomPort(env params.Env, tcp bool, allowedTCP, allowedUDP []uint16) (port uint16, err error) { port, err = readPortOrZero(env, "PORT") if err != nil { - return 0, err + return 0, fmt.Errorf("environment variable PORT: %w", err) } else if port == 0 { return 0, nil } @@ -114,12 +118,12 @@ func readCustomPort(env params.Env, tcp bool, return port, nil } } - return 0, fmt.Errorf("%w: port %d for TCP protocol", ErrInvalidPort, port) + return 0, fmt.Errorf("environment variable PORT: %w: port %d for TCP protocol", ErrInvalidPort, port) } for i := range allowedUDP { if allowedUDP[i] == port { return port, nil } } - return 0, fmt.Errorf("%w: port %d for UDP protocol", ErrInvalidPort, port) + return 0, fmt.Errorf("environment variable PORT: %w: port %d for UDP protocol", ErrInvalidPort, port) } diff --git a/internal/configuration/provider_test.go b/internal/configuration/provider_test.go index ceec2cba..7ab36992 100644 --- a/internal/configuration/provider_test.go +++ b/internal/configuration/provider_test.go @@ -348,7 +348,7 @@ func Test_readProtocol(t *testing.T) { }{ "error": { mockErr: errDummy, - err: errDummy, + err: errors.New("environment variable PROTOCOL: dummy"), }, "success": { mockStr: "tcp", diff --git a/internal/configuration/publicip.go b/internal/configuration/publicip.go index 2c8f4a17..c934b46c 100644 --- a/internal/configuration/publicip.go +++ b/internal/configuration/publicip.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strings" "time" @@ -32,14 +33,14 @@ func (settings *PublicIP) lines() (lines []string) { func (settings *PublicIP) read(r reader) (err error) { settings.Period, err = r.env.Duration("PUBLICIP_PERIOD", params.Default("12h")) if err != nil { - return err + return fmt.Errorf("environment variable PUBLICIP_PERIOD: %w", err) } settings.IPFilepath, err = r.env.Path("PUBLICIP_FILE", params.CaseSensitiveValue(), params.Default("/tmp/gluetun/ip"), params.RetroKeys([]string{"IP_STATUS_FILE"}, r.onRetroActive)) if err != nil { - return err + return fmt.Errorf("environment variable PUBLICIP_FILE (or IP_STATUS_FILE): %w", err) } return nil diff --git a/internal/configuration/purevpn.go b/internal/configuration/purevpn.go index 238a9792..e8b728c9 100644 --- a/internal/configuration/purevpn.go +++ b/internal/configuration/purevpn.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -39,22 +41,22 @@ func (settings *Provider) readPurevpn(r reader) (err error) { settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PurevpnRegionChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PurevpnCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PurevpnCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PurevpnHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/reader.go b/internal/configuration/reader.go index f36f141f..40e04b06 100644 --- a/internal/configuration/reader.go +++ b/internal/configuration/reader.go @@ -53,11 +53,9 @@ func readCSVPorts(env params.Env, key string) (ports []uint16, err error) { for i, portStr := range portsStr { portInt, err := strconv.Atoi(portStr) if err != nil { - return nil, fmt.Errorf("%w: %q from environment variable %s: %s", - ErrInvalidPort, portStr, key, err) + return nil, fmt.Errorf("%w: %s: %s", ErrInvalidPort, portStr, err) } else if portInt <= 0 || portInt > 65535 { - return nil, fmt.Errorf("%w: %d from environment variable %s: must be between 1 and 65535", - ErrInvalidPort, portInt, key) + return nil, fmt.Errorf("%w: %d: must be between 1 and 65535", ErrInvalidPort, portInt) } ports[i] = uint16(portInt) } @@ -83,11 +81,10 @@ func readCSVIPNets(env params.Env, key string, options ...params.OptionSetter) ( for i, ipNetStr := range ipNetsStr { _, ipNet, err := net.ParseCIDR(ipNetStr) if err != nil { - return nil, fmt.Errorf("%w: %q from environment variable %s: %s", - ErrInvalidIPNet, ipNetStr, key, err) + return nil, fmt.Errorf("%w: %s: %s", + ErrInvalidIPNet, ipNetStr, err) } else if ipNet == nil { - return nil, fmt.Errorf("%w: %q from environment variable %s: subnet is nil", - ErrInvalidIPNet, ipNetStr, key) + return nil, fmt.Errorf("%w: %s: subnet is nil", ErrInvalidIPNet, ipNetStr) } ipNets[i] = *ipNet } diff --git a/internal/configuration/secrets.go b/internal/configuration/secrets.go index 1959143e..84e63270 100644 --- a/internal/configuration/secrets.go +++ b/internal/configuration/secrets.go @@ -37,13 +37,15 @@ func (r *reader) getFromEnvOrSecretFile(envKey string, compulsory bool, retroKey return value, nil } + secretFilepathEnvKey := envKey + "_SECRETFILE" defaultSecretFile := "/run/secrets/" + strings.ToLower(envKey) - filepath, err := r.env.Get(envKey+"_SECRETFILE", + filepath, err := r.env.Get(secretFilepathEnvKey, params.CaseSensitiveValue(), params.Default(defaultSecretFile), ) if err != nil { - return "", fmt.Errorf("%w: %s", ErrGetSecretFilepath, err) + return "", fmt.Errorf("%w: environment variable %s: %s", + ErrGetSecretFilepath, secretFilepathEnvKey, err) } file, fileErr := r.os.OpenFile(filepath, os.O_RDONLY, 0) @@ -74,12 +76,13 @@ func (r *reader) getFromEnvOrSecretFile(envKey string, compulsory bool, retroKey func (r *reader) getFromFileOrSecretFile(secretName, filepath string) ( b []byte, err error) { defaultSecretFile := "/run/secrets/" + strings.ToLower(secretName) - secretFilepath, err := r.env.Get(strings.ToUpper(secretName)+"_SECRETFILE", + key := strings.ToUpper(secretName) + "_SECRETFILE" + secretFilepath, err := r.env.Get(key, params.CaseSensitiveValue(), params.Default(defaultSecretFile), ) if err != nil { - return b, fmt.Errorf("%w: %s", ErrGetSecretFilepath, err) + return b, fmt.Errorf("environment variable %s: %w: %s", key, ErrGetSecretFilepath, err) } b, err = readFromFile(r.os.OpenFile, secretFilepath) diff --git a/internal/configuration/server.go b/internal/configuration/server.go index b5464078..420c509a 100644 --- a/internal/configuration/server.go +++ b/internal/configuration/server.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strconv" "strings" @@ -32,7 +33,7 @@ func (settings *ControlServer) lines() (lines []string) { func (settings *ControlServer) read(r reader) (err error) { settings.Log, err = r.env.OnOff("HTTP_CONTROL_SERVER_LOG", params.Default("on")) if err != nil { - return err + return fmt.Errorf("environment variable HTTP_CONTROL_SERVER_LOG: %w", err) } var warning string @@ -42,7 +43,7 @@ func (settings *ControlServer) read(r reader) (err error) { r.logger.Warn(warning) } if err != nil { - return err + return fmt.Errorf("environment variable HTTP_CONTROL_SERVER_PORT: %w", err) } return nil diff --git a/internal/configuration/settings.go b/internal/configuration/settings.go index b9a13dfc..a8ec95db 100644 --- a/internal/configuration/settings.go +++ b/internal/configuration/settings.go @@ -67,7 +67,7 @@ func (settings *Settings) Read(env params.Env, os os.OS, logger logging.Logger) settings.VersionInformation, err = r.env.OnOff("VERSION_INFORMATION", params.Default("on")) if err != nil { - return err + return fmt.Errorf("environment variable VERSION_INFORMATION: %w", err) } if err := settings.OpenVPN.read(r); err != nil { diff --git a/internal/configuration/shadowsocks.go b/internal/configuration/shadowsocks.go index 2af6cfb0..d9734d31 100644 --- a/internal/configuration/shadowsocks.go +++ b/internal/configuration/shadowsocks.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strconv" "strings" @@ -40,8 +41,10 @@ func (settings *ShadowSocks) lines() (lines []string) { func (settings *ShadowSocks) read(r reader) (err error) { settings.Enabled, err = r.env.OnOff("SHADOWSOCKS", params.Default("off")) - if err != nil || !settings.Enabled { - return err + if !settings.Enabled { + return nil + } else if err != nil { + return fmt.Errorf("environment variable SHADOWSOCKS: %w", err) } settings.Password, err = r.getFromEnvOrSecretFile("SHADOWSOCKS_PASSWORD", settings.Enabled, nil) @@ -51,12 +54,12 @@ func (settings *ShadowSocks) read(r reader) (err error) { settings.Log, err = r.env.OnOff("SHADOWSOCKS_LOG", params.Default("off")) if err != nil { - return err + return fmt.Errorf("environment variable SHADOWSOCKS_LOG: %w", err) } settings.Method, err = r.env.Get("SHADOWSOCKS_METHOD", params.Default("chacha20-ietf-poly1305")) if err != nil { - return err + return fmt.Errorf("environment variable SHADOWSOCKS_METHOD: %w", err) } var warning string @@ -65,7 +68,7 @@ func (settings *ShadowSocks) read(r reader) (err error) { r.logger.Warn(warning) } if err != nil { - return err + return fmt.Errorf("environment variable SHADOWSOCKS_PORT: %w", err) } return nil diff --git a/internal/configuration/surfshark.go b/internal/configuration/surfshark.go index 0115614b..020bb6e9 100644 --- a/internal/configuration/surfshark.go +++ b/internal/configuration/surfshark.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -31,12 +33,12 @@ func (settings *Provider) readSurfshark(r reader) (err error) { settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.SurfsharkRegionChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.SurfsharkHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/system.go b/internal/configuration/system.go index d65827e3..fff97d9b 100644 --- a/internal/configuration/system.go +++ b/internal/configuration/system.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strconv" "strings" @@ -36,18 +37,18 @@ func (settings *System) read(r reader) (err error) { settings.PUID, err = r.env.IntRange("PUID", 0, maxID, params.Default("1000"), params.RetroKeys([]string{"UID"}, r.onRetroActive)) if err != nil { - return err + return fmt.Errorf("environment variable PUID (or UID): %w", err) } settings.PGID, err = r.env.IntRange("PGID", 0, maxID, params.Default("1000"), params.RetroKeys([]string{"GID"}, r.onRetroActive)) if err != nil { - return err + return fmt.Errorf("environment variable PGID (or GID): %w", err) } settings.Timezone, err = r.env.Get("TZ") if err != nil { - return err + return fmt.Errorf("environment variable TZ: %w", err) } return nil diff --git a/internal/configuration/torguard.go b/internal/configuration/torguard.go index d94b3630..7e2b96a2 100644 --- a/internal/configuration/torguard.go +++ b/internal/configuration/torguard.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -35,17 +37,17 @@ func (settings *Provider) readTorguard(r reader) (err error) { settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.TorguardCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.TorguardCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.TorguardHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } return nil diff --git a/internal/configuration/unbound.go b/internal/configuration/unbound.go index bd6bd2ed..c89eeac7 100644 --- a/internal/configuration/unbound.go +++ b/internal/configuration/unbound.go @@ -19,31 +19,31 @@ func (settings *DNS) readUnbound(r reader) (err error) { settings.Unbound.Caching, err = r.env.OnOff("DOT_CACHING", params.Default("on")) if err != nil { - return err + return fmt.Errorf("environment variable DOT_CACHING: %w", err) } settings.Unbound.IPv4 = true settings.Unbound.IPv6, err = r.env.OnOff("DOT_IPV6", params.Default("off")) if err != nil { - return err + return fmt.Errorf("environment variable DOT_IPV6: %w", err) } verbosityLevel, err := r.env.IntRange("DOT_VERBOSITY", 0, 5, params.Default("1")) //nolint:gomnd if err != nil { - return err + return fmt.Errorf("environment variable DOT_VERBOSITY: %w", err) } settings.Unbound.VerbosityLevel = uint8(verbosityLevel) verbosityDetailsLevel, err := r.env.IntRange("DOT_VERBOSITY_DETAILS", 0, 4, params.Default("0")) //nolint:gomnd if err != nil { - return err + return fmt.Errorf("environment variable DOT_VERBOSITY_DETAILS: %w", err) } settings.Unbound.VerbosityDetailsLevel = uint8(verbosityDetailsLevel) validationLogLevel, err := r.env.IntRange("DOT_VALIDATION_LOGLEVEL", 0, 2, params.Default("0")) //nolint:gomnd if err != nil { - return err + return fmt.Errorf("environment variable DOT_VALIDATION_LOGLEVEL: %w", err) } settings.Unbound.ValidationLogLevel = uint8(validationLogLevel) @@ -62,7 +62,7 @@ var ( func (settings *DNS) readUnboundProviders(env params.Env) (err error) { s, err := env.Get("DOT_PROVIDERS", params.Default("cloudflare")) if err != nil { - return err + return fmt.Errorf("environment variable DOT_PROVIDERS: %w", err) } for _, field := range strings.Split(s, ",") { dnsProvider, err := provider.Parse(field) diff --git a/internal/configuration/updater.go b/internal/configuration/updater.go index 588bfeac..ce2a0a96 100644 --- a/internal/configuration/updater.go +++ b/internal/configuration/updater.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strings" "time" @@ -74,7 +75,7 @@ func (settings *Updater) read(r reader) (err error) { settings.Period, err = r.env.Duration("UPDATER_PERIOD", params.Default("0")) if err != nil { - return err + return fmt.Errorf("environment variable UPDATER_PERIOD: %w", err) } return nil diff --git a/internal/configuration/vpnunlimited.go b/internal/configuration/vpnunlimited.go index 859f528b..5b4878b0 100644 --- a/internal/configuration/vpnunlimited.go +++ b/internal/configuration/vpnunlimited.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" "github.com/qdm12/golibs/params" ) @@ -58,27 +60,27 @@ func (settings *Provider) readVPNUnlimited(r reader) (err error) { settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.VPNUnlimitedCountryChoices()) if err != nil { - return err + return fmt.Errorf("environment variable COUNTRY: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.VPNUnlimitedCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.VPNUnlimitedHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } settings.ServerSelection.FreeOnly, err = r.env.YesNo("FREE_ONLY", params.Default("no")) if err != nil { - return err + return fmt.Errorf("environment variable FREE_ONLY: %w", err) } settings.ServerSelection.StreamOnly, err = r.env.YesNo("STREAM_ONLY", params.Default("no")) if err != nil { - return err + return fmt.Errorf("environment variable STREAM_ONLY: %w", err) } return nil diff --git a/internal/configuration/vyprvpn.go b/internal/configuration/vyprvpn.go index 68c94b92..28f47866 100644 --- a/internal/configuration/vyprvpn.go +++ b/internal/configuration/vyprvpn.go @@ -1,6 +1,8 @@ package configuration import ( + "fmt" + "github.com/qdm12/gluetun/internal/constants" ) @@ -27,7 +29,7 @@ func (settings *Provider) readVyprvpn(r reader) (err error) { settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.VyprvpnRegionChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } return nil diff --git a/internal/configuration/windscribe.go b/internal/configuration/windscribe.go index 0a9a4325..f30eabc4 100644 --- a/internal/configuration/windscribe.go +++ b/internal/configuration/windscribe.go @@ -1,6 +1,7 @@ package configuration import ( + "fmt" "strconv" "github.com/qdm12/gluetun/internal/constants" @@ -41,17 +42,17 @@ func (settings *Provider) readWindscribe(r reader) (err error) { settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.WindscribeRegionChoices()) if err != nil { - return err + return fmt.Errorf("environment variable REGION: %w", err) } settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.WindscribeCityChoices()) if err != nil { - return err + return fmt.Errorf("environment variable CITY: %w", err) } settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.WindscribeHostnameChoices()) if err != nil { - return err + return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err) } settings.ServerSelection.CustomPort, err = readCustomPort(r.env, settings.ServerSelection.TCP,