feat: add memory event setting to WOOP policy (#395)

castai/resource_workload_scaling_policy.go

@@ -102,6 +102,23 @@ func resourceWorkloadScalingPolicy() *schema.Resource {
 							Optional: true,
 							Description: `Defines the apply type to be used when downscaling.
 	- IMMEDIATE - pods are restarted immediately when new recommendation is generated.
+	- DEFERRED - pods are not restarted and recommendation values are applied during natural restarts only (new deployment, etc.)`,
+							ValidateDiagFunc: validation.ToDiagFunc(validation.StringInSlice([]string{"IMMEDIATE", "DEFERRED"}, false)),
+						},
+					},
+				},
+			},
+			"memory_event": {
+				Type:     schema.TypeList,
+				Optional: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"apply_type": {
+							Type:     schema.TypeString,
+							Optional: true,
+							Description: `Defines the apply type to be used when applying recommendation for memory related event.
+	- IMMEDIATE - pods are restarted immediately when new recommendation is generated.
 	- DEFERRED - pods are not restarted and recommendation values are applied during natural restarts only (new deployment, etc.)`,
 							ValidateDiagFunc: validation.ToDiagFunc(validation.StringInSlice([]string{"IMMEDIATE", "DEFERRED"}, false)),
 						},
@@ -199,6 +216,8 @@ func resourceWorkloadScalingPolicyCreate(ctx context.Context, d *schema.Resource
 
 	req.RecommendationPolicies.Downscaling = toDownscaling(toSection(d, "downscaling"))
 
+	req.RecommendationPolicies.MemoryEvent = toMemoryEvent(toSection(d, "memory_event"))
+
 	resp, err := client.WorkloadOptimizationAPICreateWorkloadScalingPolicyWithResponse(ctx, clusterID, req)
 	if checkErr := sdk.CheckOKResponse(resp, err); checkErr != nil {
 		return diag.FromErr(checkErr)
@@ -250,6 +269,9 @@ func resourceWorkloadScalingPolicyRead(ctx context.Context, d *schema.ResourceDa
 	if err := d.Set("downscaling", toDownscalingMap(sp.RecommendationPolicies.Downscaling)); err != nil {
 		return diag.FromErr(fmt.Errorf("setting downscaling: %w", err))
 	}
+	if err := d.Set("memory_event", toMemoryEventMap(sp.RecommendationPolicies.MemoryEvent)); err != nil {
+		return diag.FromErr(fmt.Errorf("setting memory event: %w", err))
+	}
 
 	return nil
 }
@@ -263,6 +285,7 @@ func resourceWorkloadScalingPolicyUpdate(ctx context.Context, d *schema.Resource
 		"memory",
 		"startup",
 		"downscaling",
+		"memory_event",
 	) {
 		tflog.Info(ctx, "scaling policy up to date")
 		return nil
@@ -279,6 +302,7 @@ func resourceWorkloadScalingPolicyUpdate(ctx context.Context, d *schema.Resource
 			Memory:           toWorkloadScalingPolicies(d.Get("memory").([]interface{})[0].(map[string]interface{})),
 			Startup:          toStartup(toSection(d, "startup")),
 			Downscaling:      toDownscaling(toSection(d, "downscaling")),
+			MemoryEvent:      toMemoryEvent(toSection(d, "memory_event")),
 		},
 	}
 
@@ -486,3 +510,35 @@ func toDownscalingMap(s *sdk.WorkloadoptimizationV1DownscalingSettings) []map[st
 
 	return []map[string]any{m}
 }
+
+func toMemoryEvent(memoryEvent map[string]any) *sdk.WorkloadoptimizationV1MemoryEventSettings {
+	if len(memoryEvent) == 0 {
+		return nil
+	}
+
+	result := &sdk.WorkloadoptimizationV1MemoryEventSettings{}
+
+	if v, ok := memoryEvent["apply_type"].(string); ok && v != "" {
+		result.ApplyType = lo.ToPtr(sdk.WorkloadoptimizationV1ApplyType(v))
+	}
+
+	return result
+}
+
+func toMemoryEventMap(s *sdk.WorkloadoptimizationV1MemoryEventSettings) []map[string]any {
+	if s == nil {
+		return nil
+	}
+
+	m := map[string]any{}
+
+	if s.ApplyType != nil {
+		m["apply_type"] = string(*s.ApplyType)
+	}
+
+	if len(m) == 0 {
+		return nil
+	}
+
+	return []map[string]any{m}
+}

castai/resource_workload_scaling_policy_test.go

@@ -75,6 +75,7 @@ func TestAccResourceWorkloadScalingPolicy(t *testing.T) {
 					resource.TestCheckResourceAttr(resourceName, "memory.0.max", "512"),
 					resource.TestCheckResourceAttr(resourceName, "startup.0.period_seconds", "123"),
 					resource.TestCheckResourceAttr(resourceName, "downscaling.0.apply_type", "DEFERRED"),
+					resource.TestCheckResourceAttr(resourceName, "memory_event.0.apply_type", "DEFERRED"),
 				),
 			},
 		},
@@ -148,6 +149,9 @@ func scalingPolicyConfigUpdated(clusterName, projectID, name string) string {
 	    downscaling {
 		    apply_type = "DEFERRED"
 	    }
+		memory_event {
+			apply_type = "DEFERRED"
+		}
 	}`, updatedName)
 
 	return ConfigCompose(testAccGKEClusterConfig(name, clusterName, projectID), cfg)

examples/resources/castai_workload_scaling_policy/resource.tf

@@ -23,4 +23,7 @@ resource "castai_workload_scaling_policy" "services" {
   downscaling {
     apply_type = "DEFERRED"
   }
+  downscaling {
+    apply_type = "IMMEDIATE"
+  }
 }