avoid weight adjustment on managed routes owned header rule

Author: schlags

pkg/plugin/httproute.go

@@ -9,6 +9,7 @@ import (
 	"github.com/argoproj-labs/rollouts-plugin-trafficrouter-gatewayapi/internal/utils"
 	"github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1"
 	pluginTypes "github.com/argoproj/argo-rollouts/utils/plugin/types"
+	"github.com/sirupsen/logrus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 )
@@ -19,10 +20,12 @@ const (
 
 func (r *RpcPlugin) setHTTPRouteWeight(rollout *v1alpha1.Rollout, desiredWeight int32, gatewayAPIConfig *GatewayAPITrafficRouting) pluginTypes.RpcError {
 	ctx := context.TODO()
+	clientset := r.TestClientset
 	httpRouteClient := r.HTTPRouteClient
 	if !r.IsTest {
 		gatewayClientV1 := r.GatewayAPIClientset.GatewayV1()
 		httpRouteClient = gatewayClientV1.HTTPRoutes(gatewayAPIConfig.Namespace)
+		clientset = r.Clientset.CoreV1().ConfigMaps(gatewayAPIConfig.Namespace)
 	}
 	httpRoute, err := httpRouteClient.Get(ctx, gatewayAPIConfig.HTTPRoute, metav1.GetOptions{})
 	if err != nil {
@@ -32,16 +35,63 @@ func (r *RpcPlugin) setHTTPRouteWeight(rollout *v1alpha1.Rollout, desiredWeight
 	}
 	canaryServiceName := rollout.Spec.Strategy.Canary.CanaryService
 	stableServiceName := rollout.Spec.Strategy.Canary.StableService
+
+	// Retrieve the managed routes from the configmap to determine which rules were added via setHTTPHeaderRoute
+	managedRouteMap := make(ManagedRouteMap)
+	configMap, err := utils.GetOrCreateConfigMap(gatewayAPIConfig.ConfigMap, utils.CreateConfigMapOptions{
+		Clientset: clientset,
+		Ctx:       ctx,
+	})
+	if err != nil {
+		return pluginTypes.RpcError{
+			ErrorString: err.Error(),
+		}
+	}
+	err = utils.GetConfigMapData(configMap, HTTPConfigMapKey, &managedRouteMap)
+	if err != nil {
+		return pluginTypes.RpcError{
+			ErrorString: err.Error(),
+		}
+	}
+	managedRuleIndices := make(map[int]bool)
+	for _, managedRoute := range managedRouteMap {
+		if idx, ok := managedRoute[httpRoute.Name]; ok {
+			managedRuleIndices[idx] = true
+		}
+	}
+
 	routeRuleList := HTTPRouteRuleList(httpRoute.Spec.Rules)
-	canaryBackendRefs, err := getBackendRefs(canaryServiceName, routeRuleList)
+	indexedCanaryBackendRefs, err := getIndexedBackendRefs(canaryServiceName, routeRuleList)
 	if err != nil {
 		return pluginTypes.RpcError{
 			ErrorString: err.Error(),
 		}
 	}
+	canaryBackendRefs := make([]*HTTPBackendRef, 0)
+	for _, indexedCanaryBackendRef := range indexedCanaryBackendRefs {
+		// TODO - when setMirrorRoute is implemented, we would need to update the weight of the managed
+		// canary backendRefs for mirror routes.
+		// Ideally - these would be stored differently in the configmap from the managed header based routes
+		// but that would mean a breaking change to the configmap structure
+		if managedRuleIndices[indexedCanaryBackendRef.RuleIndex] {
+			r.LogCtx.WithFields(logrus.Fields{
+				"rule":            httpRoute.Spec.Rules[indexedCanaryBackendRef.RuleIndex],
+				"index":           indexedCanaryBackendRef.RuleIndex,
+				"managedRouteMap": managedRouteMap,
+			}).Info("Skipping matched canary backendRef for weight adjustment since it is a part of a rule marked as a managed route")
+			continue
+		}
+		canaryBackendRefs = append(canaryBackendRefs, indexedCanaryBackendRef.Refs...)
+	}
+
+	// Update the weight of the canary backendRefs not owned by a rule marked as a managed route
 	for _, ref := range canaryBackendRefs {
 		ref.Weight = &desiredWeight
 	}
+
+	// Noted above, but any managed routes that would have a stableBackendRef would be updated with weight here.
+	// Since this is not yet possible (all managed routes will only have a single canary backendRef),
+	// we can avoid checking for managed route rule indexes here.
 	stableBackendRefs, err := getBackendRefs(stableServiceName, routeRuleList)
 	if err != nil {
 		return pluginTypes.RpcError{

pkg/plugin/plugin.go

@@ -280,6 +280,37 @@ func getBackendRefs[T1 GatewayAPIBackendRef, T2 GatewayAPIRouteRule[T1], T3 Gate
 	return nil, routeRuleList.Error()
 }
 
+// This will return the backendRefs slices that matched the backendRefName but split by the routeRule index to be used for updating the weight
+// under consideration of the managedRoute rules present from the configmap (identifiable by the index of the rule on an HttpRoute)
+func getIndexedBackendRefs[T1 GatewayAPIBackendRef, T2 GatewayAPIRouteRule[T1], T3 GatewayAPIRouteRuleList[T1, T2]](backendRefName string, routeRuleList T3) ([]IndexedBackendRefs[T1], error) {
+	var results []IndexedBackendRefs[T1]
+	var backendRef T1
+	var routeRule T2
+	ruleIndex := 0
+	for next, hasNext := routeRuleList.Iterator(); hasNext; {
+		// Has to be inside of the for loop since it will be reset to 0 for each routeRule
+		var matchedRefs []T1
+		routeRule, hasNext = next()
+		for nextRef, hasNextRef := routeRule.Iterator(); hasNextRef; {
+			backendRef, hasNextRef = nextRef()
+			if backendRefName == backendRef.GetName() {
+				matchedRefs = append(matchedRefs, backendRef)
+			}
+		}
+		if len(matchedRefs) > 0 {
+			results = append(results, IndexedBackendRefs[T1]{
+				RuleIndex: ruleIndex,
+				Refs:      matchedRefs,
+			})
+		}
+		ruleIndex++
+	}
+	if len(results) > 0 {
+		return results, nil
+	}
+	return nil, routeRuleList.Error()
+}
+
 func isConfigHasRoutes(config *GatewayAPITrafficRouting) bool {
 	return len(config.HTTPRoutes) > 0 || len(config.TCPRoutes) > 0 || len(config.GRPCRoutes) > 0
 }

pkg/plugin/plugin_test.go

@@ -106,6 +106,7 @@ func TestRunSuccessfully(t *testing.T) {
 		rollout := newRollout(mocks.StableServiceName, mocks.CanaryServiceName, &GatewayAPITrafficRouting{
 			Namespace: mocks.RolloutNamespace,
 			HTTPRoute: mocks.HTTPRouteName,
+			ConfigMap: mocks.ConfigMapName,
 		})
 		err := pluginInstance.SetWeight(rollout, desiredWeight, []v1alpha1.WeightDestination{})
 
@@ -155,6 +156,7 @@ func TestRunSuccessfully(t *testing.T) {
 						UseHeaderRoutes: true,
 					},
 				},
+				ConfigMap: mocks.ConfigMapName,
 			})
 		err := pluginInstance.SetWeight(rollout, desiredWeight, []v1alpha1.WeightDestination{})
 

pkg/plugin/types.go

@@ -129,3 +129,8 @@ type GatewayAPIBackendRef interface {
 type GatewayAPIRouteRuleListIterator[T1 GatewayAPIBackendRef, T2 GatewayAPIRouteRule[T1]] func() (T2, bool)
 
 type GatewayAPIRouteRuleIterator[T1 GatewayAPIBackendRef] func() (T1, bool)
+
+type IndexedBackendRefs[T GatewayAPIBackendRef] struct {
+	RuleIndex int
+	Refs      []T
+}

test/e2e/constants.go

@@ -33,6 +33,7 @@ const (
 
 	FIRST_CANARY_ROUTE_WEIGHT = 0
 	LAST_CANARY_ROUTE_WEIGHT  = 30
+	DEFAULT_ROUTE_WEIGHT      = 1 // HTTPRoute rules that are managed by the rollout should never update their weight to the setWeight value. It should stay as the default 1
 
 	RESOURCES_MAP_KEY contextKey = "resourcesMap"
 

test/e2e/single_header_based_httproute_test.go

@@ -272,7 +272,7 @@ func getMatchHeaderBasedHTTPRouteFetcher(t *testing.T, targetWeight int32, targe
 		}
 		headerBasedRouteValue := rules[HEADER_BASED_RULE_INDEX].Matches[HEADER_BASED_MATCH_INDEX].Headers[HEADER_BASED_HEADER_INDEX]
 		weight := *rules[HEADER_BASED_RULE_INDEX].BackendRefs[HEADER_BASED_BACKEND_REF_INDEX].Weight
-		return weight == targetWeight && isHeaderBasedHTTPRouteValuesEqual(headerBasedRouteValue, targetHeaderBasedRouteValue)
+		return weight == DEFAULT_ROUTE_WEIGHT && isHeaderBasedHTTPRouteValuesEqual(headerBasedRouteValue, targetHeaderBasedRouteValue)
 	}
 }