Refactor: Make errors use the parent's error level

- All wrapped errors have to be created with types.NewWrappedError to
inherit the error level from the parent
- Or types.NewWrappedErrorLevel can be used which means a custom error
level is given. For example this is done with cancelling OAuth
- Client public errors are forwarded with handleError that also logs
it with the error's level

5 files changed, 70 insertions, 70 deletions

diff --git a/internal/server/api.go b/internal/server/api.go
index 05d2528..be7281c 100644
--- a/internal/server/api.go
+++ b/internal/server/api.go
@@ -17,21 +17,21 @@ func APIGetEndpoints(baseURL string) (*ServerEndpoints, error) {
 	errorMessage := "failed getting server endpoints"
 	url, urlErr := url.Parse(baseURL)
 	if urlErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: urlErr}
+		return nil, types.NewWrappedError(errorMessage, urlErr)
 	}
 
 	url.Path = path.Join(url.Path, WellKnownPath)
 	_, body, bodyErr := httpw.HTTPGet(url.String())
 
 	if bodyErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: bodyErr}
+		return nil, types.NewWrappedError(errorMessage, bodyErr)
 	}
 
 	endpoints := &ServerEndpoints{}
 	jsonErr := json.Unmarshal(body, endpoints)
 
 	if jsonErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: jsonErr}
+		return nil, types.NewWrappedError(errorMessage, jsonErr)
 	}
 
 	return endpoints, nil
@@ -51,20 +51,20 @@ func apiAuthorized(
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return nil, nil, types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	// Join the paths
 	url, urlErr := url.Parse(base.Endpoints.API.V3.API)
 	if urlErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: urlErr}
+		return nil, nil, types.NewWrappedError(errorMessage, urlErr)
 	}
 	url.Path = path.Join(url.Path, endpoint)
 
 	// Make sure the tokens are valid, this will return an error if re-login is needed
 	oauthErr := EnsureTokens(server)
 	if oauthErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: oauthErr}
+		return nil, nil, types.NewWrappedError(errorMessage, oauthErr)
 	}
 
 	headerKey := "Authorization"
@@ -95,11 +95,11 @@ func apiAuthorizedRetry(
 			MarkTokenExpired(server)
 			retryHeader, retryBody, retryErr := apiAuthorized(server, method, endpoint, opts)
 			if retryErr != nil {
-				return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: retryErr}
+				return nil, nil, types.NewWrappedError(errorMessage, retryErr)
 			}
 			return retryHeader, retryBody, nil
 		}
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: bodyErr}
+		return nil, nil, types.NewWrappedError(errorMessage, bodyErr)
 	}
 	return header, body, nil
 }
@@ -108,19 +108,19 @@ func APIInfo(server Server) error {
 	errorMessage := "failed API /info"
 	_, body, bodyErr := apiAuthorizedRetry(server, http.MethodGet, "/info", nil)
 	if bodyErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: bodyErr}
+		return types.NewWrappedError(errorMessage, bodyErr)
 	}
 	structure := ServerProfileInfo{}
 	jsonErr := json.Unmarshal(body, &structure)
 
 	if jsonErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: jsonErr}
+		return types.NewWrappedError(errorMessage, jsonErr)
 	}
 
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	// Store the profiles and make sure that the current profile is not overwritten
@@ -169,17 +169,17 @@ func APIConnectWireguard(
 		&httpw.HTTPOptionalParams{Headers: headers, Body: urlForm},
 	)
 	if connectErr != nil {
-		return "", "", time.Time{}, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     connectErr,
-		}
+		return "", "", time.Time{}, types.NewWrappedError(
+			errorMessage,
+			connectErr,
+		)
 	}
 
 	expires := header.Get("expires")
 
 	pTime, pTimeErr := http.ParseTime(expires)
 	if pTimeErr != nil {
-		return "", "", time.Time{}, &types.WrappedErrorMessage{Message: errorMessage, Err: pTimeErr}
+		return "", "", time.Time{}, types.NewWrappedError(errorMessage, pTimeErr)
 	}
 
 	contentType := header.Get("content-type")
@@ -210,13 +210,13 @@ func APIConnectOpenVPN(server Server, profile_id string, preferTCP bool) (string
 		&httpw.HTTPOptionalParams{Headers: headers, Body: urlForm},
 	)
 	if connectErr != nil {
-		return "", time.Time{}, &types.WrappedErrorMessage{Message: errorMessage, Err: connectErr}
+		return "", time.Time{}, types.NewWrappedError(errorMessage, connectErr)
 	}
 
 	expires := header.Get("expires")
 	pTime, pTimeErr := http.ParseTime(expires)
 	if pTimeErr != nil {
-		return "", time.Time{}, &types.WrappedErrorMessage{Message: errorMessage, Err: pTimeErr}
+		return "", time.Time{}, types.NewWrappedError(errorMessage, pTimeErr)
 	}
 	return string(connectBody), pTime, nil
 }
diff --git a/internal/server/common.go b/internal/server/common.go
index bf72bc6..bf6f4ca 100644
--- a/internal/server/common.go
+++ b/internal/server/common.go
@@ -97,10 +97,10 @@ func (servers *Servers) GetCurrentServer() (Server, error) {
 	errorMessage := "failed getting current server"
 	if servers.IsType == SecureInternetServerType {
 		if !servers.HasSecureLocation() {
-			return nil, &types.WrappedErrorMessage{
-				Message: errorMessage,
-				Err:     &ServerGetCurrentNotFoundError{},
-			}
+			return nil, types.NewWrappedError(
+				errorMessage,
+				&ServerGetCurrentNotFoundError{},
+			)
 		}
 		return &servers.SecureInternetHomeServer, nil
 	}
@@ -113,18 +113,18 @@ func (servers *Servers) GetCurrentServer() (Server, error) {
 	currentServerURL := serversStruct.CurrentURL
 	bases := serversStruct.Map
 	if bases == nil {
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &ServerGetCurrentNoMapError{},
-		}
+		return nil, types.NewWrappedError(
+			errorMessage,
+			&ServerGetCurrentNoMapError{},
+		)
 	}
 	server, exists := bases[currentServerURL]
 
 	if !exists || server == nil {
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &ServerGetCurrentNotFoundError{},
-		}
+		return nil, types.NewWrappedError(
+			errorMessage,
+			&ServerGetCurrentNotFoundError{},
+		)
 	}
 	return server, nil
 }
@@ -161,7 +161,7 @@ func (servers *Servers) addInstituteAndCustom(
 		discoServer.SupportContact,
 	)
 	if instituteInitErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: instituteInitErr}
+		return nil, types.NewWrappedError(errorMessage, instituteInitErr)
 	}
 	toAddServers.Map[url] = server
 	servers.IsType = serverType
@@ -192,7 +192,7 @@ func (servers *Servers) SetSecureLocation(
 	_, addLocationErr := servers.SecureInternetHomeServer.addLocation(chosenLocationServer)
 
 	if addLocationErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: addLocationErr}
+		return types.NewWrappedError(errorMessage, addLocationErr)
 	}
 
 	servers.SecureInternetHomeServer.CurrentLocation = chosenLocationServer.CountryCode
@@ -209,7 +209,7 @@ func (servers *Servers) AddSecureInternet(
 	initErr := servers.SecureInternetHomeServer.init(secureOrg, secureServer)
 
 	if initErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: initErr}
+		return nil, types.NewWrappedError(errorMessage, initErr)
 	}
 
 	servers.IsType = SecureInternetServerType
@@ -255,7 +255,7 @@ func ShouldRenewButton(server Server) bool {
 func GetISS(server Server) (string, error) {
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return "", &types.WrappedErrorMessage{Message: "failed getting server ISS", Err: baseErr}
+		return "", types.NewWrappedError("failed getting server ISS", baseErr)
 	}
 	// We have already ensured that the base URL ends with a /
 	return base.URL, nil
@@ -288,7 +288,7 @@ func MarkTokensForRenew(server Server) {
 func EnsureTokens(server Server) error {
 	ensureErr := server.GetOAuth().EnsureTokens()
 	if ensureErr != nil {
-		return &types.WrappedErrorMessage{Message: "failed ensuring server tokens", Err: ensureErr}
+		return types.NewWrappedError("failed ensuring server tokens", ensureErr)
 	}
 	return nil
 }
@@ -323,7 +323,7 @@ func getCurrentProfile(server Server) (*ServerProfile, error) {
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return nil, types.NewWrappedError(errorMessage, baseErr)
 	}
 	profileID := base.Profiles.Current
 	for _, profile := range base.Profiles.Info.ProfileList {
@@ -332,10 +332,10 @@ func getCurrentProfile(server Server) (*ServerProfile, error) {
 		}
 	}
 
-	return nil, &types.WrappedErrorMessage{
-		Message: errorMessage,
-		Err:     &ServerGetCurrentProfileNotFoundError{ProfileID: profileID},
-	}
+	return nil, types.NewWrappedError(
+		errorMessage,
+		&ServerGetCurrentProfileNotFoundError{ProfileID: profileID},
+	)
 }
 
 func wireguardGetConfig(server Server, preferTCP bool, supportsOpenVPN bool) (string, string, error) {
@@ -343,14 +343,14 @@ func wireguardGetConfig(server Server, preferTCP bool, supportsOpenVPN bool) (st
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return "", "", types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	profile_id := base.Profiles.Current
 	wireguardKey, wireguardErr := wireguard.GenerateKey()
 
 	if wireguardErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: wireguardErr}
+		return "", "", types.NewWrappedError(errorMessage, wireguardErr)
 	}
 
 	wireguardPublicKey := wireguardKey.PublicKey().String()
@@ -363,7 +363,7 @@ func wireguardGetConfig(server Server, preferTCP bool, supportsOpenVPN bool) (st
 	)
 
 	if configErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
+		return "", "", types.NewWrappedError(errorMessage, configErr)
 	}
 
 	// Store start and end time
@@ -386,7 +386,7 @@ func openVPNGetConfig(server Server, preferTCP bool) (string, string, error) {
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return "", "", types.NewWrappedError(errorMessage, baseErr)
 	}
 	profile_id := base.Profiles.Current
 	configOpenVPN, expires, configErr := APIConnectOpenVPN(server, profile_id, preferTCP)
@@ -396,7 +396,7 @@ func openVPNGetConfig(server Server, preferTCP bool) (string, string, error) {
 	base.EndTime = expires
 
 	if configErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
+		return "", "", types.NewWrappedError(errorMessage, configErr)
 	}
 
 	return configOpenVPN, "openvpn", nil
@@ -409,12 +409,12 @@ func HasValidProfile(server Server) (bool, error) {
 	// This does not override the current profile
 	infoErr := APIInfo(server)
 	if infoErr != nil {
-		return false, &types.WrappedErrorMessage{Message: errorMessage, Err: infoErr}
+		return false, types.NewWrappedError(errorMessage, infoErr)
 	}
 
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return false, &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return false, types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	// If there was a profile chosen and it doesn't exist anymore, reset it
@@ -442,7 +442,7 @@ func GetConfig(server Server, preferTCP bool) (string, string, error) {
 
 	profile, profileErr := getCurrentProfile(server)
 	if profileErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: profileErr}
+		return "", "", types.NewWrappedError(errorMessage, profileErr)
 	}
 
 	supportsOpenVPN := profile.supportsOpenVPN()
@@ -461,7 +461,7 @@ func GetConfig(server Server, preferTCP bool) (string, string, error) {
 	}
 
 	if configErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
+		return "", "", types.NewWrappedError(errorMessage, configErr)
 	}
 
 	return config, configType, nil
diff --git a/internal/server/custom.go b/internal/server/custom.go
index feda1f3..6ba6503 100644
--- a/internal/server/custom.go
+++ b/internal/server/custom.go
@@ -11,18 +11,18 @@ func (servers *Servers) SetCustomServer(server Server) error {
 	errorMessage := "failed setting custom server"
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	if base.Type != "custom_server" {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("Not a custom server")}
+		return types.NewWrappedError(errorMessage, errors.New("Not a custom server"))
 	}
 
 	if _, ok := servers.CustomServers.Map[base.URL]; ok {
 		servers.CustomServers.CurrentURL = base.URL
 		servers.IsType = CustomServerType
 	} else {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("Not a custom server")}
+		return types.NewWrappedError(errorMessage, errors.New("Not a custom server"))
 	}
 	return nil
 }
@@ -31,7 +31,7 @@ func (servers *Servers) GetCustomServer(url string) (*InstituteAccessServer, err
 	if server, ok := servers.CustomServers.Map[url]; ok {
 		return server, nil
 	}
-	return nil, &types.WrappedErrorMessage{Message: "failed to get institute access server", Err: fmt.Errorf("No custom server with URL: %s", url)}
+	return nil, types.NewWrappedError("failed to get institute access server", fmt.Errorf("No custom server with URL: %s", url))
 }
 
 func (servers *Servers) RemoveCustomServer(url string) {
diff --git a/internal/server/instituteaccess.go b/internal/server/instituteaccess.go
index bf0e2bc..0f097b0 100644
--- a/internal/server/instituteaccess.go
+++ b/internal/server/instituteaccess.go
@@ -26,18 +26,18 @@ func (servers *Servers) SetInstituteAccess(server Server) error {
 	errorMessage := "failed setting institute access server"
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	if base.Type != "institute_access" {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("Not an institute access server")}
+		return types.NewWrappedError(errorMessage, errors.New("Not an institute access server"))
 	}
 
 	if _, ok := servers.InstituteServers.Map[base.URL]; ok {
 		servers.InstituteServers.CurrentURL = base.URL
 		servers.IsType = InstituteAccessServerType
 	} else {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("No such institute access server")}
+		return types.NewWrappedError(errorMessage, errors.New("No such institute access server"))
 	}
 	return nil
 }
@@ -46,7 +46,7 @@ func (servers *Servers) GetInstituteAccess(url string) (*InstituteAccessServer,
 	if server, ok := servers.InstituteServers.Map[url]; ok {
 		return server, nil
 	}
-	return nil, &types.WrappedErrorMessage{Message: "failed to get institute access server", Err: fmt.Errorf("No institute access server with URL: %s", url)}
+	return nil, types.NewWrappedError("failed to get institute access server", fmt.Errorf("No institute access server with URL: %s", url))
 }
 
 func (servers *Servers) RemoveInstituteAccess(url string) {
@@ -91,7 +91,7 @@ func (institute *InstituteAccessServer) init(
 	institute.Base.Type = serverType
 	endpoints, endpointsErr := APIGetEndpoints(url)
 	if endpointsErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: endpointsErr}
+		return types.NewWrappedError(errorMessage, endpointsErr)
 	}
 	institute.OAuth.Init(endpoints.API.V3.Authorization, endpoints.API.V3.Token)
 	institute.Base.Endpoints = *endpoints
diff --git a/internal/server/secureinternet.go b/internal/server/secureinternet.go
index 27d48a5..93e83cf 100644
--- a/internal/server/secureinternet.go
+++ b/internal/server/secureinternet.go
@@ -35,11 +35,11 @@ func (servers *Servers) SetSecureInternet(server Server) error {
 	errorMessage := "failed setting secure internet server"
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	if base.Type != "secure_internet" {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("Not a secure internet server")}
+		return types.NewWrappedError(errorMessage, errors.New("Not a secure internet server"))
 	}
 
 	// The location should already be configured
@@ -71,19 +71,19 @@ func (secure *SecureInternetHomeServer) GetTemplateAuth() func(string) string {
 func (server *SecureInternetHomeServer) GetBase() (*ServerBase, error) {
 	errorMessage := "failed getting current secure internet home base"
 	if server.BaseMap == nil {
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &ServerSecureInternetMapNotFoundError{},
-		}
+		return nil, types.NewWrappedError(
+			errorMessage,
+			&ServerSecureInternetMapNotFoundError{},
+		)
 	}
 
 	base, exists := server.BaseMap[server.CurrentLocation]
 
 	if !exists {
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &ServerSecureInternetBaseNotFoundError{Current: server.CurrentLocation},
-		}
+		return nil, types.NewWrappedError(
+			errorMessage,
+			&ServerSecureInternetBaseNotFoundError{Current: server.CurrentLocation},
+		)
 	}
 	return base, nil
 }
@@ -113,7 +113,7 @@ func (secure *SecureInternetHomeServer) addLocation(
 		base.Type = "secure_internet"
 		endpoints, endpointsErr := APIGetEndpoints(locationServer.BaseURL)
 		if endpointsErr != nil {
-			return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: endpointsErr}
+			return nil, types.NewWrappedError(errorMessage, endpointsErr)
 		}
 		base.Endpoints = *endpoints
 	}
@@ -145,7 +145,7 @@ func (secure *SecureInternetHomeServer) init(
 	base, baseErr := secure.addLocation(homeLocation)
 
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	// Make sure oauth contains our endpoints