Extend multimetric rules combination

Modifications on CRD to include operators and the new logical operators
allOf/anyOf. This would allow multimetrics combinations within a rule
in the same strategy.

Author: togashidm

telemetry-aware-scheduling/deploy/tas-policy-crd.yaml

@@ -35,13 +35,18 @@ spec:
                    properties:
                      policyName:
                        type: string
+                     logicalOperator:
+                       type: string
+                       enum: ["allOf", "anyOf"]
                      rules:
                        items:
+                         description: Set rules parameters per strategy
                          properties:
                            metricname:
                              type: string
                            operator:
                              type: string
+                             enum: ["Equals","LessThan","GreaterThan"]
                            target:
                              format: int64
                              type: integer

telemetry-aware-scheduling/pkg/strategies/deschedule/strategy.go

@@ -30,22 +30,42 @@ func (d *Strategy) StrategyType() string {
 //Returns a map of nodeNames as key with an empty value associated with each.
 func (d *Strategy) Violated(cache cache.Reader) map[string]interface{} {
 	violatingNodes := map[string]interface{}{}
+	nodeMetricViol := map[string]int{}
+
 	for _, rule := range d.Rules {
 		nodeMetrics, err := cache.ReadMetric(rule.Metricname)
+
 		if err != nil {
 			klog.V(2).InfoS(err.Error(), "component", "controller")
+
 			continue
 		}
+
 		for nodeName, nodeMetric := range nodeMetrics {
 			msg := fmt.Sprint(nodeName+" "+rule.Metricname, " = ", nodeMetric.Value.AsDec())
 			klog.V(4).InfoS(msg, "component", "controller")
+
 			if core.EvaluateRule(nodeMetric.Value, rule) {
-				msg := fmt.Sprintf(nodeName + " violating " + d.PolicyName + ": " + ruleToString(rule))
-				klog.V(2).InfoS(msg, "component", "controller")
-				violatingNodes[nodeName] = nil
+				klog.V(2).Infof("%v violated in node %v", rule.Metricname, nodeName)
+				nodeMetricViol[nodeName]++
+
+				if d.LogicalOperator == "allOf" {
+					if nodeMetricViol[nodeName] == len(d.Rules) {
+						msg := fmt.Sprint(nodeName + " violating all the rules in " + d.StrategyType() + " strategy")
+						klog.V(2).InfoS(msg, "component", "controller")
+
+						violatingNodes[nodeName] = nil
+					}
+				} else {
+					msg := fmt.Sprintf(nodeName + " violating " + d.PolicyName + ": " + ruleToString(rule))
+					klog.V(2).InfoS(msg, "component", "controller")
+
+					violatingNodes[nodeName] = nil
+				}
 			}
 		}
 	}
+
 	return violatingNodes
 }
 

telemetry-aware-scheduling/pkg/strategies/dontschedule/strategy.go

@@ -24,22 +24,40 @@ const (
 //If any single rule is violated the method returns a set of nodes that are currently in violation.
 func (d *Strategy) Violated(cache cache.Reader) map[string]interface{} {
 	violatingNodes := map[string]interface{}{}
+	nodeMetricViol := map[string]int{}
+
 	for _, rule := range d.Rules {
 		nodeMetrics, err := cache.ReadMetric(rule.Metricname)
 		if err != nil {
 			klog.V(2).InfoS(err.Error(), "component", "controller")
+
 			continue
 		}
+
 		for nodeName, nodeMetric := range nodeMetrics {
 			msg := fmt.Sprint(nodeName+" "+rule.Metricname, " = ", nodeMetric.Value.AsDec())
 			klog.V(2).InfoS(msg, "component", "controller")
+
 			if core.EvaluateRule(nodeMetric.Value, rule) {
-				msg := fmt.Sprint(nodeName + " violating " + d.PolicyName + ": " + ruleToString(rule))
-				klog.V(2).InfoS(msg, "component", "controller")
-				violatingNodes[nodeName] = nil
+				nodeMetricViol[nodeName]++
+
+				if d.LogicalOperator == "allOf" {
+					if nodeMetricViol[nodeName] == len(d.Rules) {
+						msg := fmt.Sprint(nodeName + " violating all the rules in " + d.StrategyType() + " strategy")
+						klog.V(2).InfoS(msg, "component", "controller")
+
+						violatingNodes[nodeName] = nil
+					}
+				} else {
+					msg := fmt.Sprint(nodeName + " violating " + d.PolicyName + ": " + ruleToString(rule))
+					klog.V(2).InfoS(msg, "component", "controller")
+
+					violatingNodes[nodeName] = nil
+				}
 			}
 		}
 	}
+
 	return violatingNodes
 }
 
@@ -56,6 +74,7 @@ func (d *Strategy) StrategyType() string {
 //Equals implementation which checks to see if all rules and the policy name are equal for this strategy and another.
 //Used to avoid duplications and to find the correct strategy for deletions in the index.
 func (d *Strategy) Equals(other core.Interface) bool {
+
 	OtherDontScheduleStrategy, ok := other.(*Strategy)
 	sameName := other.GetPolicyName() == d.GetPolicyName()
 	if ok && sameName && len(d.Rules) > 0 && len(d.Rules) == len(OtherDontScheduleStrategy.Rules) {

telemetry-aware-scheduling/pkg/strategies/labeling/strategy.go

@@ -78,6 +78,18 @@ func (d *Strategy) Violated(cache cache.Reader) map[string]interface{} {
 		}
 	}
 
+	if d.LogicalOperator == "allOf" {
+		for nodeName := range violatingNodes {
+			if _, ok := violatingNodes[nodeName]; ok {
+				if res, ok := violatingNodes[nodeName].(*violationResultType); ok {
+					if len(res.ruleResults) != len(d.Rules) {
+						delete(violatingNodes, nodeName)
+					}
+				}
+			}
+		}
+	}
+
 	return violatingNodes
 }
 

telemetry-aware-scheduling/pkg/telemetrypolicy/api/v1alpha1/types.go

@@ -23,8 +23,9 @@ type TASPolicy struct {
 
 // TASPolicyStrategy contains a set of TASPolicyRule which define the strategy.
 type TASPolicyStrategy struct {
-	PolicyName string          `json:"policyName"`
-	Rules      []TASPolicyRule `json:"rules"`
+	PolicyName      string          `json:"policyName"`
+	LogicalOperator string          `json:"logicalOperator,omitempty"`
+	Rules           []TASPolicyRule `json:"rules"`
 }
 
 // TASPolicyRule contains the parameters for the strategy rule.