feat: Add rollout behavior to workload optimization scaling policy

Author: zrudzionis

castai/resource_workload_scaling_policy.go

@@ -36,6 +36,9 @@ const (
 	FieldLimitStrategyType                         = "type"
 	FieldLimitStrategyMultiplier                   = "multiplier"
 	FieldConfidence                                = "confidence"
+	FieldRolloutBehavior                           = "rollout_behavior"
+	FieldType                                      = "type"
+	FieldRolloutBehaviorNoDisruptionType           = "NO_DISRUPTION"
 	FieldPredictiveScaling                         = "predictive_scaling"
 	FieldConfidenceThreshold                       = "threshold"
 	DeprecatedFieldApplyThreshold                  = "apply_threshold"
@@ -268,6 +271,23 @@ It can be either:
 					},
 				},
 			},
+			FieldRolloutBehavior: {
+				Type:        schema.TypeList,
+				Optional:    true,
+				MaxItems:    1,
+				Description: "Defines the rollout behavior used when applying recommendations.",
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						FieldType: {
+							Type:     schema.TypeString,
+							Required: true,
+							Description: `Defines the rollout type to be used when applying recommendations.
+	- NO_DISRUPTION - pods are restarted without causing service disruption.`,
+							ValidateDiagFunc: validation.ToDiagFunc(validation.StringInSlice([]string{FieldRolloutBehaviorNoDisruptionType}, false)),
+						},
+					},
+				},
+			},
 		},
 		Timeouts: &schema.ResourceTimeout{
 			Create: schema.DefaultTimeout(15 * time.Second),
@@ -544,6 +564,8 @@ func resourceWorkloadScalingPolicyCreate(ctx context.Context, d *schema.Resource
 
 	req.RecommendationPolicies.PredictiveScaling = toPredictiveScaling(toSection(d, FieldPredictiveScaling))
 
+	req.RecommendationPolicies.RolloutBehavior = toRolloutBehavior(toSection(d, FieldRolloutBehavior))
+
 	ar, err := toAssignmentRules(toSection(d, FieldAssignmentRules))
 	if err != nil {
 		return diag.FromErr(err)
@@ -627,6 +649,9 @@ func resourceWorkloadScalingPolicyRead(ctx context.Context, d *schema.ResourceDa
 	if err := d.Set(FieldPredictiveScaling, toPredictiveScalingMap(sp.RecommendationPolicies.PredictiveScaling)); err != nil {
 		return diag.FromErr(fmt.Errorf("setting predictive scaling: %w", err))
 	}
+	if err := d.Set(FieldRolloutBehavior, toRolloutBehaviorMap(sp.RecommendationPolicies.RolloutBehavior)); err != nil {
+		return diag.FromErr(fmt.Errorf("setting rollout behavior: %w", err))
+	}
 
 	if err := d.Set(FieldAssignmentRules, toAssignmentRulesMap(getResourceFrom(d, FieldAssignmentRules), sp.AssignmentRules)); err != nil {
 		return diag.FromErr(fmt.Errorf("setting assignment rules: %w", err))
@@ -656,6 +681,7 @@ func resourceWorkloadScalingPolicyUpdate(ctx context.Context, d *schema.Resource
 		FieldConfidence,
 		FieldAssignmentRules,
 		FieldPredictiveScaling,
+		FieldRolloutBehavior,
 	) {
 		tflog.Info(ctx, "scaling policy up to date")
 		return nil
@@ -690,6 +716,7 @@ func resourceWorkloadScalingPolicyUpdate(ctx context.Context, d *schema.Resource
 			AntiAffinity:      toAntiAffinity(toSection(d, "anti_affinity")),
 			Confidence:        toConfidence(toSection(d, FieldConfidence)),
 			PredictiveScaling: toPredictiveScaling(toSection(d, FieldPredictiveScaling)),
+			RolloutBehavior:   toRolloutBehavior(toSection(d, FieldRolloutBehavior)),
 		},
 	}
 
@@ -1250,6 +1277,31 @@ func toPredictiveScalingResource(m map[string]any) *sdk.WorkloadoptimizationV1Pr
 	return r
 }
 
+func toRolloutBehavior(m map[string]any) *sdk.WorkloadoptimizationV1RolloutBehaviorSettings {
+	if len(m) == 0 {
+		return nil
+	}
+
+	r := &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{}
+	if v, ok := m[FieldType].(string); ok && v != "" {
+		r.Type = lo.ToPtr(sdk.WorkloadoptimizationV1RolloutBehaviorType(v))
+	}
+
+	return r
+}
+
+func toRolloutBehaviorMap(s *sdk.WorkloadoptimizationV1RolloutBehaviorSettings) []map[string]any {
+	if s == nil {
+		return nil
+	}
+
+	return []map[string]any{
+		{
+			FieldType: s.Type,
+		},
+	}
+}
+
 func getWorkloadScalingPolicyByName(ctx context.Context, client sdk.ClientWithResponsesInterface, clusterID, name string) (*sdk.WorkloadoptimizationV1WorkloadScalingPolicy, error) {
 	list, err := client.WorkloadOptimizationAPIListWorkloadScalingPoliciesWithResponse(ctx, clusterID)
 	if checkErr := sdk.CheckOKResponse(list, err); checkErr != nil {

castai/resource_workload_scaling_policy_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
+	"github.com/samber/lo"
 	"github.com/stretchr/testify/require"
 
 	"github.com/castai/terraform-provider-castai/castai/sdk"
@@ -108,6 +109,7 @@ func TestAccResourceWorkloadScalingPolicy(t *testing.T) {
 					resource.TestCheckResourceAttr(resourceName, "assignment_rules.0.rules.1.workload.0.labels_expressions.0.key", "helm.sh/chart"),
 					resource.TestCheckResourceAttr(resourceName, "assignment_rules.0.rules.1.workload.0.labels_expressions.0.operator", "DoesNotExist"),
 					resource.TestCheckResourceAttr(resourceName, "predictive_scaling.0.cpu.0.enabled", "true"),
+					resource.TestCheckResourceAttr(resourceName, "rollout_behavior.0.type", "NO_DISRUPTION"),
 				),
 			},
 		},
@@ -221,6 +223,9 @@ func scalingPolicyConfigUpdated(clusterName, projectID, name string) string {
 				enabled = true
 			}
 		}
+		rollout_behavior {
+			type = "NO_DISRUPTION"
+		}
 		cpu {
 			function 		= "QUANTILE"
 			overhead 		= 0.15
@@ -433,3 +438,30 @@ func Test_toPredictiveScaling(t *testing.T) {
 		})
 	}
 }
+
+func Test_toRolloutBehavior(t *testing.T) {
+	tests := map[string]struct {
+		args map[string]any
+		exp  *sdk.WorkloadoptimizationV1RolloutBehaviorSettings
+	}{
+		"should return rollout behavior settings": {
+			args: map[string]any{
+				FieldType: FieldRolloutBehaviorNoDisruptionType,
+			},
+			exp: &sdk.WorkloadoptimizationV1RolloutBehaviorSettings{
+				Type: lo.ToPtr(sdk.NODISRUPTION),
+			},
+		},
+		"should return nil on empty map": {
+			args: map[string]any{},
+			exp:  nil,
+		},
+	}
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			r := require.New(t)
+			got := toRolloutBehavior(tt.args)
+			r.Equal(tt.exp, got)
+		})
+	}
+}

docs/resources/workload_scaling_policy.md

@@ -68,4 +68,7 @@ resource "castai_workload_scaling_policy" "services" {
   confidence {
     threshold = 0.9
   }
+  rollout_behavior {
+    type = "NO_DISRUPTION"
+  }
 }