Updates pro sub and DB with QPF CustomDiff validation

Author: trentrosenbaum

provider/resource_rediscloud_pro_database.go

@@ -49,7 +49,7 @@ func resourceRedisCloudProDatabase() *schema.Resource {
 			Delete: schema.DefaultTimeout(10 * time.Minute),
 		},
 
-		CustomizeDiff: remoteBackupIntervalSetCorrectly("remote_backup"),
+		CustomizeDiff: customizeDiff(),
 
 		Schema: map[string]*schema.Schema{
 			"subscription_id": {
@@ -91,12 +91,6 @@ func resourceRedisCloudProDatabase() *schema.Resource {
 				Computed:     true,
 				ExactlyOneOf: []string{"memory_limit_in_gb", "dataset_size_in_gb"},
 			},
-			"query_performance_factor": {
-				Description: "Query performance factor for this specific database",
-				Type:        schema.TypeString,
-				Optional:    true,
-				Computed:    true,
-			},
 			"support_oss_cluster_api": {
 				Description: "Support Redis open-source (OSS) Cluster API",
 				Type:        schema.TypeBool,
@@ -221,6 +215,13 @@ func resourceRedisCloudProDatabase() *schema.Resource {
 					},
 				},
 			},
+			"query_performance_factor": {
+				Description: "Query performance factor for this specific database",
+				Type:        schema.TypeString,
+				Optional:    true,
+				Computed:    true,
+				ForceNew:    true,
+			},
 			"modules": {
 				Description: "Modules to be provisioned in the database",
 				Type:        schema.TypeSet,
@@ -521,6 +522,10 @@ func resourceRedisCloudProDatabaseRead(ctx context.Context, d *schema.ResourceDa
 		return diag.FromErr(err)
 	}
 
+	if err := d.Set("query_performance_factor", redis.StringValue(db.QueryPerformanceFactor)); err != nil {
+		return diag.FromErr(err)
+	}
+
 	if err := d.Set("modules", flattenModules(db.Modules)); err != nil {
 		return diag.FromErr(err)
 	}
@@ -593,6 +598,11 @@ func resourceRedisCloudProDatabaseRead(ctx context.Context, d *schema.ResourceDa
 		return diag.FromErr(err)
 	}
 
+	////query_performance_factor
+	//if err := d.Set("query_performance_factor", redis.String(*db.)); err != nil {
+	//	return diag.FromErr(err)
+	//}
+
 	if err := readTags(ctx, api, subId, dbId, d); err != nil {
 		return diag.FromErr(err)
 	}
@@ -882,6 +892,61 @@ func skipDiffIfIntervalIs12And12HourTimeDiff(k, oldValue, newValue string, d *sc
 	return oldTime.Minute() == newTime.Minute() && oldTime.Add(12*time.Hour).Hour() == newTime.Hour()
 }
 
+func customizeDiff() schema.CustomizeDiffFunc {
+	return func(ctx context.Context, diff *schema.ResourceDiff, meta interface{}) error {
+		if err := validateQueryPerformanceFactor()(ctx, diff, meta); err != nil {
+			return err
+		}
+		if err := remoteBackupIntervalSetCorrectly("remote_backup")(ctx, diff, meta); err != nil {
+			return err
+		}
+		return nil
+	}
+}
+
+func validateQueryPerformanceFactor() schema.CustomizeDiffFunc {
+	return func(ctx context.Context, diff *schema.ResourceDiff, meta interface{}) error {
+		// Check if "query_performance_factor" is set
+		qpf, qpfExists := diff.GetOk("query_performance_factor")
+
+		// Ensure "modules" is explicitly defined in the HCL
+		_, modulesExists := diff.GetOkExists("modules")
+
+		if qpfExists && qpf.(string) != "" {
+			if !modulesExists {
+				return fmt.Errorf(`"query_performance_factor" requires the "modules" key to be explicitly defined in HCL`)
+			}
+
+			// Retrieve modules as a slice of interfaces
+			rawModules := diff.Get("modules").(*schema.Set).List()
+
+			// Convert modules to []map[string]interface{}
+			var modules []map[string]interface{}
+			for _, rawModule := range rawModules {
+				if moduleMap, ok := rawModule.(map[string]interface{}); ok {
+					modules = append(modules, moduleMap)
+				}
+			}
+
+			// Check if "RediSearch" exists
+			if !containsDBModule(modules, "RediSearch") {
+				return fmt.Errorf(`"query_performance_factor" requires the "modules" list to contain "RediSearch"`)
+			}
+		}
+		return nil
+	}
+}
+
+// Helper function to check if a module exists
+func containsDBModule(modules []map[string]interface{}, moduleName string) bool {
+	for _, module := range modules {
+		if name, ok := module["name"].(string); ok && name == moduleName {
+			return true
+		}
+	}
+	return false
+}
+
 func remoteBackupIntervalSetCorrectly(key string) schema.CustomizeDiffFunc {
 	// Validate multiple attributes - https://github.com/hashicorp/terraform-plugin-sdk/issues/233
 

provider/resource_rediscloud_pro_database_test.go

@@ -310,7 +310,7 @@ resource "rediscloud_subscription" "example" {
     quantity = 1
     replication=false
     support_oss_cluster_api=false
-    modules = []
+    modules = ["RediSearch"]
   }
 }
 `

provider/resource_rediscloud_pro_subscription.go

@@ -21,26 +21,60 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
 )
 
+func containsModule(modules []interface{}, requiredModule string) bool {
+	for _, m := range modules {
+		if mod, ok := m.(string); ok && mod == requiredModule {
+			return true
+		}
+	}
+	return false
+}
+
 func resourceRedisCloudProSubscription() *schema.Resource {
 	return &schema.Resource{
-		Description:   "Creates a Pro Subscription within your Redis Enterprise Cloud Account.",
-		CreateContext: resourceRedisCloudProSubscriptionCreate,
-		ReadContext:   resourceRedisCloudProSubscriptionRead,
-		UpdateContext: resourceRedisCloudProSubscriptionUpdate,
-		DeleteContext: resourceRedisCloudProSubscriptionDelete,
-		CustomizeDiff: func(ctx context.Context, diff *schema.ResourceDiff, i interface{}) error {
-			_, cPlanExists := diff.GetOk("creation_plan")
-			if cPlanExists {
+
+		CustomizeDiff: func(ctx context.Context, diff *schema.ResourceDiff, meta interface{}) error {
+
+			// Ensure the "creation_plan" block exists
+			_, creationPlanExists := diff.GetOk("creation_plan")
+			if !creationPlanExists {
+				if diff.Id() == "" {
+					return fmt.Errorf(`the "creation_plan" block is required`)
+				}
 				return nil
 			}
 
-			// The resource hasn't been created yet, but the creation plan is missing.
-			if diff.Id() == "" {
-				return fmt.Errorf(`the "creation_plan" block is required`)
+			// Validate "query_performance_factor" dependency on "modules"
+			creationPlan := diff.Get("creation_plan").([]interface{})
+			if len(creationPlan) > 0 {
+				plan := creationPlan[0].(map[string]interface{})
+
+				qpf, qpfExists := plan["query_performance_factor"].(string)
+
+				// Ensure "modules" key is explicitly defined in HCL
+				_, modulesExists := diff.GetOkExists("creation_plan.0.modules")
+
+				if qpfExists && qpf != "" {
+					if !modulesExists {
+						return fmt.Errorf(`"query_performance_factor" requires the "modules" key to be explicitly defined in HCL`)
+					}
+
+					modules, _ := plan["modules"].([]interface{})
+					if !containsModule(modules, "RediSearch") {
+						return fmt.Errorf(`"query_performance_factor" requires the "modules" list to contain "RediSearch"`)
+					}
+				}
 			}
+
 			return nil
 		},
 
+		Description:   "Creates a Pro Subscription within your Redis Enterprise Cloud Account.",
+		CreateContext: resourceRedisCloudProSubscriptionCreate,
+		ReadContext:   resourceRedisCloudProSubscriptionRead,
+		UpdateContext: resourceRedisCloudProSubscriptionUpdate,
+		DeleteContext: resourceRedisCloudProSubscriptionDelete,
+
 		Importer: &schema.ResourceImporter{
 			// Let the READ operation do the heavy lifting for importing values from the API.
 			StateContext: schema.ImportStatePassthroughContext,
@@ -259,6 +293,8 @@ func resourceRedisCloudProSubscription() *schema.Resource {
 							Description: "Query performance factor for this specific database",
 							Type:        schema.TypeString,
 							Optional:    true,
+							Computed:    true,
+							ForceNew:    true,
 						},
 						"throughput_measurement_by": {
 							Description:      "Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)",
@@ -804,7 +840,7 @@ func buildSubscriptionCreatePlanDatabases(memoryStorage string, planMap map[stri
 	}
 
 	queryPerformanceFactor := ""
-	if v, ok := planMap["queryPerformanceFactor"]; ok && v != nil {
+	if v, ok := planMap["query_performance_factor"]; ok && v != nil {
 		queryPerformanceFactor = v.(string)
 	}