feat: Evaluate state based on priority

Author: PythonGermany

config/config.go

@@ -517,26 +517,37 @@ func ValidateStatesConfig(config *Config) error { // TODO#227 Add tests
 		}
 	}
 
-	// Validate custom states TODO#227 Validate that priorities don't
+	// Validate custom states
 	stateNames := make(map[string]bool)
+	statePriorities := make(map[int]string)
 	for _, state := range config.States {
 		// Check for duplicate state names
 		if stateNames[state.Name] {
 			return fmt.Errorf("duplicate state name: %s", state.Name)
 		}
 		stateNames[state.Name] = true
+
+		// Check for duplicate state priorities
+		if existingState, exists := statePriorities[state.Priority]; exists {
+			return fmt.Errorf("priority of state '%s' (%d) conflicts with state '%s'", state.Name, state.Priority, existingState)
+		}
+		statePriorities[state.Priority] = state.Name
+
 		// Validate the state configuration
 		if err := state.ValidateAndSetDefaults(); err != nil {
 			return fmt.Errorf("invalid state '%s': %w", state.Name, err)
 		}
 	}
-	logr.Infof("[config.ValidateStatesConfig] Validated %d state(s)", len(config.States))
+	logr.Infof("[config.ValidateStatesConfig] Validated %d state(s) (%d custom)", len(config.States), len(config.States)-len(defaultStates))
 	return nil
 }
 
 func ValidateEndpointsConfig(config *Config) error {
-	duplicateValidationMap := make(map[string]bool)
+	// Set state configuration for all endpoints
+	endpoint.SetStateConfig(config.States)
+
 	// Validate endpoints
+	duplicateValidationMap := make(map[string]bool)
 	for _, ep := range config.Endpoints {
 		logr.Debugf("[config.ValidateEndpointsConfig] Validating endpoint with key %s", ep.Key())
 		if endpointKey := ep.Key(); duplicateValidationMap[endpointKey] {
@@ -549,6 +560,7 @@ func ValidateEndpointsConfig(config *Config) error {
 		}
 	}
 	logr.Infof("[config.ValidateEndpointsConfig] Validated %d endpoints", len(config.Endpoints))
+
 	// Validate external endpoints
 	for _, ee := range config.ExternalEndpoints {
 		logr.Debugf("[config.ValidateEndpointsConfig] Validating external endpoint '%s'", ee.Key())
@@ -561,6 +573,7 @@ func ValidateEndpointsConfig(config *Config) error {
 			return fmt.Errorf("invalid external endpoint %s: %w", ee.Key(), err)
 		}
 	}
+
 	logr.Infof("[config.ValidateEndpointsConfig] Validated %d external endpoints", len(config.ExternalEndpoints))
 	return nil
 }

config/endpoint/condition.go

@@ -38,14 +38,14 @@ func (c Condition) evaluate(result *Result, dontResolveFailedConditions bool, co
 	condition := string(c)
 	success := false
 
-	var linkedState string
+	var linkedStateName string
 	if strings.Contains(condition, "::") {
 		conditionParts := strings.Split(condition, "::")
 		if len(conditionParts) != 2 { // TODO#227 Not sure if this makes sense. Checking that it is 2 or more should be enough. Then there is no character restriction in the remaining condition.
 			result.AddError(fmt.Sprintf("invalid linked state syntax: %s", condition))
 			return false
 		}
-		linkedState = conditionParts[0]
+		linkedStateName = conditionParts[0]
 		condition = conditionParts[1]
 	}
 
@@ -93,7 +93,8 @@ func (c Condition) evaluate(result *Result, dontResolveFailedConditions bool, co
 	if !success {
 		//logr.Debugf("[Condition.evaluate] Condition '%s' did not succeed because '%s' is false", condition, condition)
 	}
-	result.ConditionResults = append(result.ConditionResults, &ConditionResult{Condition: conditionToDisplay, Success: success, LinkedState: linkedState})
+
+	result.ConditionResults = append(result.ConditionResults, &ConditionResult{Condition: conditionToDisplay, Success: success, LinkedStateName: linkedStateName})
 	return success
 }
 

config/endpoint/condition_result.go

@@ -8,6 +8,6 @@ type ConditionResult struct {
 	// Success whether the condition was met (successful) or not (failed)
 	Success bool `json:"success"`
 
-	// The state the condition is linked to
-	LinkedState string `json:"-"`
+	// Name of the state the condition is linked to
+	LinkedStateName string `json:"-"`
 }

config/endpoint/endpoint.go

@@ -75,6 +75,9 @@ var (
 	// This is because the free whois service we are using should not be abused, especially considering the fact that
 	// the data takes a while to be updated.
 	ErrInvalidEndpointIntervalForDomainExpirationPlaceholder = errors.New("the minimum interval for an endpoint with a condition using the " + DomainExpirationPlaceholder + " placeholder is 300s (5m)")
+
+	// State config
+	states []*state.State
 )
 
 // Endpoint is the configuration of a service to be monitored
@@ -152,6 +155,19 @@ type Endpoint struct {
 	AlwaysRun bool `yaml:"always-run,omitempty"`
 }
 
+func SetStateConfig(cfg []*state.State) {
+	states = cfg
+}
+
+func FindStateByName(name string) *state.State {
+	for _, state := range states {
+		if state.Name == name {
+			return state
+		}
+	}
+	return nil
+}
+
 // IsEnabled returns whether the endpoint is enabled or not
 func (e *Endpoint) IsEnabled() bool {
 	if e.Enabled == nil {
@@ -341,10 +357,14 @@ func (e *Endpoint) EvaluateHealthWithContext(context *gontext.Gontext) *Result {
 	if result.Success {
 		result.State = state.DefaultHealthyStateName
 	} else { // Go over condition results to see if any of them has a specific state to set
+		highestPrioritySeen := 0
 		for _, conditionResult := range result.ConditionResults {
-			if !conditionResult.Success && len(conditionResult.LinkedState) > 0 {
-				result.State = conditionResult.LinkedState // TODO#227 Only set if no other state with higher priority has been set
-				break
+			if !conditionResult.Success && len(conditionResult.LinkedStateName) > 0 {
+				linkedState := FindStateByName(conditionResult.LinkedStateName)
+				if linkedState != nil && (linkedState.Priority > highestPrioritySeen) {
+					highestPrioritySeen = linkedState.Priority
+					result.State = conditionResult.LinkedStateName
+				}
 			}
 		}
 		if len(result.State) == 0 {