1 files changed, 55 insertions, 96 deletions

diff --git a/internal/server/secureinternet.go b/internal/server/secureinternet.go
index 998390d..12263a6 100644
--- a/internal/server/secureinternet.go
+++ b/internal/server/secureinternet.go
@@ -1,15 +1,13 @@
 package server
 
 import (
-	"errors"
-	"fmt"
-
 	"github.com/eduvpn/eduvpn-common/internal/oauth"
 	"github.com/eduvpn/eduvpn-common/internal/util"
 	"github.com/eduvpn/eduvpn-common/types"
+	"github.com/go-errors/errors"
 )
 
-// A secure internet server which has its own OAuth tokens
+// SecureInternetHomeServer secure internet server which has its own OAuth tokens
 // It specifies the current location url it is connected to.
 type SecureInternetHomeServer struct {
 	Auth        oauth.OAuth       `json:"oauth"`
@@ -24,150 +22,111 @@ type SecureInternetHomeServer struct {
 	CurrentLocation       string `json:"current_location"`
 }
 
-func (servers *Servers) GetSecureInternetHomeServer() (*SecureInternetHomeServer, error) {
-	if !servers.HasSecureLocation() {
-		return nil, errors.New("no secure internet home server")
+func (ss *Servers) GetSecureInternetHomeServer() (*SecureInternetHomeServer, error) {
+	if !ss.HasSecureLocation() {
+		return nil, errors.Errorf("no secure internet home server")
 	}
-	return &servers.SecureInternetHomeServer, nil
+	return &ss.SecureInternetHomeServer, nil
 }
 
-func (servers *Servers) SetSecureInternet(server Server) error {
-	errorMessage := "failed setting secure internet server"
-	base, baseErr := server.Base()
-	if baseErr != nil {
-		return types.NewWrappedError(errorMessage, baseErr)
+func (ss *Servers) SetSecureInternet(server Server) error {
+	b, err := server.Base()
+	if err != nil {
+		return err
 	}
 
-	if base.Type != "secure_internet" {
-		return types.NewWrappedError(errorMessage, errors.New("not a secure internet server"))
+	if b.Type != "secure_internet" {
+		return errors.Errorf("not a secure internet server")
 	}
 
 	// The location should already be configured
 	// TODO: check for location?
-	servers.IsType = SecureInternetServerType
+	ss.IsType = SecureInternetServerType
 	return nil
 }
 
-func (servers *Servers) RemoveSecureInternet() {
+func (ss *Servers) RemoveSecureInternet() {
 	// Empty out the struct
-	servers.SecureInternetHomeServer = SecureInternetHomeServer{}
+	ss.SecureInternetHomeServer = SecureInternetHomeServer{}
 
 	// If the current server is secure internet, default to custom server
-	if servers.IsType == SecureInternetServerType {
-		servers.IsType = CustomServerType
+	if ss.IsType == SecureInternetServerType {
+		ss.IsType = CustomServerType
 	}
 }
 
-func (server *SecureInternetHomeServer) TemplateAuth() func(string) string {
+func (s *SecureInternetHomeServer) TemplateAuth() func(string) string {
 	return func(authURL string) string {
-		return util.ReplaceWAYF(server.AuthorizationTemplate, authURL, server.HomeOrganizationID)
+		return util.ReplaceWAYF(s.AuthorizationTemplate, authURL, s.HomeOrganizationID)
 	}
 }
 
-func (server *SecureInternetHomeServer) Base() (*Base, error) {
-	errorMessage := "failed getting current secure internet home base"
-	if server.BaseMap == nil {
-		return nil, types.NewWrappedError(
-			errorMessage,
-			&SecureInternetMapNotFoundError{},
-		)
+func (s *SecureInternetHomeServer) Base() (*Base, error) {
+	if s.BaseMap == nil {
+		return nil, errors.Errorf("secure internet map not found")
 	}
 
-	base, exists := server.BaseMap[server.CurrentLocation]
-
-	if !exists {
-		return nil, types.NewWrappedError(
-			errorMessage,
-			&SecureInternetBaseNotFoundError{Current: server.CurrentLocation},
-		)
+	b, ok := s.BaseMap[s.CurrentLocation]
+	if !ok {
+		return nil, errors.Errorf("secure internet base with location '%s' not found", s.CurrentLocation)
 	}
-	return base, nil
+	return b, nil
 }
 
-func (server *SecureInternetHomeServer) OAuth() *oauth.OAuth {
-	return &server.Auth
+func (s *SecureInternetHomeServer) OAuth() *oauth.OAuth {
+	return &s.Auth
 }
 
-func (servers *Servers) HasSecureLocation() bool {
-	return servers.SecureInternetHomeServer.CurrentLocation != ""
+func (ss *Servers) HasSecureLocation() bool {
+	return ss.SecureInternetHomeServer.CurrentLocation != ""
 }
 
-func (server *SecureInternetHomeServer) addLocation(
-	locationServer *types.DiscoveryServer,
-) (*Base, error) {
-	errorMessage := "failed adding a location"
+func (s *SecureInternetHomeServer) addLocation(locSrv *types.DiscoveryServer) (*Base, error) {
 	// Initialize the base map if it is non-nil
-	if server.BaseMap == nil {
-		server.BaseMap = make(map[string]*Base)
+	if s.BaseMap == nil {
+		s.BaseMap = make(map[string]*Base)
 	}
 
 	// Add the location to the base map
-	base, exists := server.BaseMap[locationServer.CountryCode]
-
-	if !exists || base == nil {
+	b, ok := s.BaseMap[locSrv.CountryCode]
+	if !ok || b == nil {
 		// Create the base to be added to the map
-		base = &Base{}
-		base.URL = locationServer.BaseURL
-		base.DisplayName = server.DisplayName
-		base.SupportContact = locationServer.SupportContact
-		base.Type = "secure_internet"
-		endpointsErr := base.InitializeEndpoints()
-		if endpointsErr != nil {
-			return nil, types.NewWrappedError(errorMessage, endpointsErr)
+		b = &Base{}
+		b.URL = locSrv.BaseURL
+		b.DisplayName = s.DisplayName
+		b.SupportContact = locSrv.SupportContact
+		b.Type = "secure_internet"
+		if err := b.InitializeEndpoints(); err != nil {
+			return nil, err
 		}
 	}
 
 	// Ensure it is in the map
-	server.BaseMap[locationServer.CountryCode] = base
-	return base, nil
+	s.BaseMap[locSrv.CountryCode] = b
+	return b, nil
 }
 
 // Initializes the home server and adds its own location.
-func (server *SecureInternetHomeServer) init(
-	homeOrg *types.DiscoveryOrganization,
-	homeLocation *types.DiscoveryServer,
-) error {
-	errorMessage := "failed initializing secure internet home server"
-
-	if server.HomeOrganizationID != homeOrg.OrgID {
+func (s *SecureInternetHomeServer) init(
+	homeOrg *types.DiscoveryOrganization, homeLoc *types.DiscoveryServer) error {
+	if s.HomeOrganizationID != homeOrg.OrgID {
 		// New home organisation, clear everything
-		*server = SecureInternetHomeServer{}
+		*s = SecureInternetHomeServer{}
 	}
 
 	// Make sure to set the organization ID
-	server.HomeOrganizationID = homeOrg.OrgID
-	server.DisplayName = homeOrg.DisplayName
+	s.HomeOrganizationID = homeOrg.OrgID
+	s.DisplayName = homeOrg.DisplayName
 
 	// Make sure to set the authorization URL template
-	server.AuthorizationTemplate = homeLocation.AuthenticationURLTemplate
+	s.AuthorizationTemplate = homeLoc.AuthenticationURLTemplate
 
-	base, baseErr := server.addLocation(homeLocation)
-
-	if baseErr != nil {
-		return types.NewWrappedError(errorMessage, baseErr)
+	b, err := s.addLocation(homeLoc)
+	if err != nil {
+		return err
 	}
 
 	// Make sure oauth contains our endpoints
-	server.Auth.Init(base.URL, base.Endpoints.API.V3.Authorization, base.Endpoints.API.V3.Token)
+	s.Auth.Init(b.URL, b.Endpoints.API.V3.Authorization, b.Endpoints.API.V3.Token)
 	return nil
 }
-
-type SecureInternetHomeNotFoundError struct{}
-
-func (e *SecureInternetHomeNotFoundError) Error() string {
-	return "failed to get secure internet home server, not found"
-}
-
-type SecureInternetMapNotFoundError struct{}
-
-func (e *SecureInternetMapNotFoundError) Error() string {
-	return "secure internet map not found"
-}
-
-type SecureInternetBaseNotFoundError struct {
-	Current string
-}
-
-func (e *SecureInternetBaseNotFoundError) Error() string {
-	return fmt.Sprintf("secure internet base not found with current location: %s", e.Current)
-}