Merge pull request #599 from RedisLabs/feat/query_performance_factors

Adding in support for query performance factors on affected resources

Author: burythehammer

.github/workflows/terraform_provider_pr.yml

@@ -149,6 +149,19 @@ jobs:
           go-version-file: go.mod
       - run: EXECUTE_TESTS=true make testacc TESTARGS='-run="TestAccResourceRedisCloud(PrivateServiceConnect_CRUDI|AclRule_CRUDI)"'
 
+  # TODO: remove this after release
+  # qpf = query performance factor
+  go_test_smoke_qpf:
+    name: go test smoke qpf
+    needs: [ go_build ]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/setup-go@0aaccfd150d50ccaeb58ebd88d36e91967a5f35b # v5.4.0
+        with:
+          go-version-file: go.mod
+      - run: EXECUTE_TESTS=true make testacc TESTARGS='-run="TestAccResourceRedisCloudProDatabase_qpf.*"'
+
   tfproviderlint:
     name: tfproviderlint
     needs: [go_build]

provider/datasource_rediscloud_pro_database.go

@@ -59,6 +59,11 @@ func dataSourceRedisCloudProDatabase() *schema.Resource {
 				Type:        schema.TypeFloat,
 				Computed:    true,
 			},
+			"query_performance_factor": {
+				Description: "Query performance factor for this specific database",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
 			"support_oss_cluster_api": {
 				Description: "Supports the Redis open-source (OSS) Cluster API",
 				Type:        schema.TypeBool,
@@ -476,6 +481,10 @@ func dataSourceRedisCloudProDatabaseRead(ctx context.Context, d *schema.Resource
 		return diag.FromErr(err)
 	}
 
+	if err := d.Set("query_performance_factor", redis.String(*db.QueryPerformanceFactor)); err != nil {
+		return diag.FromErr(err)
+	}
+
 	return diags
 }
 

provider/datasource_rediscloud_pro_database_test.go

@@ -43,6 +43,7 @@ func TestAccDataSourceRedisCloudProDatabase_basic(t *testing.T) {
 					resource.TestCheckResourceAttrSet(dataSourceById, "public_endpoint"),
 					resource.TestCheckResourceAttrSet(dataSourceById, "private_endpoint"),
 					resource.TestCheckResourceAttr(dataSourceById, "enable_default_user", "true"),
+					resource.TestCheckResourceAttr(dataSourceById, "query_performance_factor", "2x"),
 
 					resource.TestCheckResourceAttr(dataSourceByName, "name", "tf-database"),
 					resource.TestCheckResourceAttr(dataSourceByName, "protocol", "redis"),
@@ -59,6 +60,7 @@ func TestAccDataSourceRedisCloudProDatabase_basic(t *testing.T) {
 					resource.TestCheckResourceAttrSet(dataSourceByName, "public_endpoint"),
 					resource.TestCheckResourceAttrSet(dataSourceByName, "private_endpoint"),
 					resource.TestCheckResourceAttr(dataSourceByName, "enable_default_user", "true"),
+					resource.TestCheckResourceAttr(dataSourceByName, "query_performance_factor", "2x"),
 				),
 			},
 		},
@@ -94,6 +96,8 @@ resource "rediscloud_subscription" "example" {
     support_oss_cluster_api=true
     throughput_measurement_by = "operations-per-second"
     throughput_measurement_value = 1000
+	query_performance_factor	 = "2x"
+	modules = ["RediSearch"]
   }
 }
 resource "rediscloud_subscription_database" "example" {
@@ -108,6 +112,12 @@ resource "rediscloud_subscription_database" "example" {
 	support_oss_cluster_api	     = true
 	replication				     = false
     enable_default_user 		 = true
+	query_performance_factor	 = "2x"
+	modules = [
+		{
+			name: "RediSearch"
+		}
+	]
 }
 
 data "rediscloud_database" "example-by-id" {

provider/resource_rediscloud_active_active_subscription_peering_test.go

@@ -2,12 +2,11 @@ package provider
 
 import (
 	"fmt"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
 	"os"
 	"regexp"
 	"testing"
-
-	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"
-	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
 )
 
 func TestAccResourceRedisCloudActiveActiveSubscriptionPeering_aws(t *testing.T) {

provider/resource_rediscloud_pro_database.go

@@ -3,6 +3,7 @@ package provider
 import (
 	"context"
 	"fmt"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -49,7 +50,7 @@ func resourceRedisCloudProDatabase() *schema.Resource {
 			Delete: schema.DefaultTimeout(10 * time.Minute),
 		},
 
-		CustomizeDiff: remoteBackupIntervalSetCorrectly("remote_backup"),
+		CustomizeDiff: customizeDiff(),
 
 		Schema: map[string]*schema.Schema{
 			"subscription_id": {
@@ -215,6 +216,25 @@ func resourceRedisCloudProDatabase() *schema.Resource {
 					},
 				},
 			},
+			"query_performance_factor": {
+				Description: "Query performance factor for this specific database",
+				Type:        schema.TypeString,
+				Optional:    true,
+				Computed:    true,
+				ForceNew:    true,
+				ValidateFunc: func(val interface{}, key string) (warns []string, errs []error) {
+					v := val.(string)
+					matched, err := regexp.MatchString(`^([2468])x$`, v)
+					if err != nil {
+						errs = append(errs, fmt.Errorf("regex match failed: %s", err))
+						return
+					}
+					if !matched {
+						errs = append(errs, fmt.Errorf("%q must be an even value between 2x and 8x (inclusive), got: %s", key, v))
+					}
+					return
+				},
+			},
 			"modules": {
 				Description: "Modules to be provisioned in the database",
 				Type:        schema.TypeSet,
@@ -341,6 +361,7 @@ func resourceRedisCloudProDatabaseCreate(ctx context.Context, d *schema.Resource
 	throughputMeasurementBy := d.Get("throughput_measurement_by").(string)
 	throughputMeasurementValue := d.Get("throughput_measurement_value").(int)
 	averageItemSizeInBytes := d.Get("average_item_size_in_bytes").(int)
+	queryPerformanceFactor := d.Get("query_performance_factor").(string)
 
 	createModules := make([]*databases.Module, 0)
 	modules := d.Get("modules").(*schema.Set)
@@ -388,6 +409,10 @@ func resourceRedisCloudProDatabaseCreate(ctx context.Context, d *schema.Resource
 		RemoteBackup: buildBackupPlan(d.Get("remote_backup").([]interface{}), d.Get("periodic_backup_path")),
 	}
 
+	if queryPerformanceFactor != "" {
+		createDatabase.QueryPerformanceFactor = redis.String(queryPerformanceFactor)
+	}
+
 	if password != "" {
 		createDatabase.Password = redis.String(password)
 	}
@@ -513,6 +538,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)
 	}
@@ -585,6 +614,12 @@ func resourceRedisCloudProDatabaseRead(ctx context.Context, d *schema.ResourceDa
 		return diag.FromErr(err)
 	}
 
+	if db.QueryPerformanceFactor != nil {
+		if err := d.Set("query_performance_factor", redis.String(*db.QueryPerformanceFactor)); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
 	if err := readTags(ctx, api, subId, dbId, d); err != nil {
 		return diag.FromErr(err)
 	}
@@ -681,6 +716,11 @@ func resourceRedisCloudProDatabaseUpdate(ctx context.Context, d *schema.Resource
 		update.SourceIP = []*string{redis.String("0.0.0.0/0")}
 	}
 
+	queryPerformanceFactor := d.Get("query_performance_factor").(string)
+	if queryPerformanceFactor != "" {
+		update.QueryPerformanceFactor = redis.String(queryPerformanceFactor)
+	}
+
 	if d.Get("password").(string) != "" {
 		update.Password = redis.String(d.Get("password").(string))
 	}
@@ -873,6 +913,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