feat: adding in support for query performance factors on affected resources

Author: burythehammer

go.mod

@@ -66,3 +66,5 @@ require (
 	google.golang.org/protobuf v1.35.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
+
+replace github.com/RedisLabs/rediscloud-go-api => ../rediscloud-go-api

go.sum

@@ -4,8 +4,6 @@ github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migc
 github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
 github.com/ProtonMail/go-crypto v1.1.0-alpha.2 h1:bkyFVUP+ROOARdgCiJzNQo2V2kiB97LyUpzH9P6Hrlg=
 github.com/ProtonMail/go-crypto v1.1.0-alpha.2/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
-github.com/RedisLabs/rediscloud-go-api v0.22.0 h1:Tb3vMtCq7ks5kpniF/Rkod7TvHhcXZ2oYJJT3pMgyQ8=
-github.com/RedisLabs/rediscloud-go-api v0.22.0/go.mod h1:3/oVb71rv2OstFRYEc65QCIbfwnJTgZeQhtPCcdHook=
 github.com/agext/levenshtein v1.2.2 h1:0S/Yg6LYmFJ5stwQeRp6EeOcCbj7xiqQSdNelsXvaqE=
 github.com/agext/levenshtein v1.2.2/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
 github.com/apparentlymart/go-textseg/v12 v12.0.0/go.mod h1:S/4uRK2UtaQttw1GenVJEynmyUenKwP++x/+DdGV/Ec=

provider/datasource_rediscloud_pro_database.go

@@ -59,6 +59,12 @@ func dataSourceRedisCloudProDatabase() *schema.Resource {
 				Type:        schema.TypeFloat,
 				Computed:    true,
 			},
+			"query_performance_factor": {
+				Description: "Query performance factor for this specific database",
+				Type:        schema.TypeString,
+				Optional:    true,
+				Computed:    true,
+			},
 			"support_oss_cluster_api": {
 				Description: "Supports the Redis open-source (OSS) Cluster API",
 				Type:        schema.TypeBool,

provider/datasource_rediscloud_pro_database_test.go

@@ -40,6 +40,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", "4x"),
 
 					resource.TestCheckResourceAttr(dataSourceByName, "name", "tf-database"),
 					resource.TestCheckResourceAttr(dataSourceByName, "protocol", "redis"),
@@ -56,6 +57,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", "4x"),
 				),
 			},
 		},
@@ -105,6 +107,7 @@ resource "rediscloud_subscription_database" "example" {
 	support_oss_cluster_api	     = true
 	replication				     = false
     enable_default_user 		 = true
+	query_performance_factor	 = ""
 }
 
 data "rediscloud_database" "example-by-id" {

provider/rediscloud_active_active_subscription_test.go

@@ -43,6 +43,7 @@ func TestAccResourceRedisCloudActiveActiveSubscription_CRUDI(t *testing.T) {
 					resource.TestCheckResourceAttr(resourceName, "cloud_provider", "AWS"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.#", "1"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.memory_limit_in_gb", "1"),
+					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.query_performance_factor", "4x"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.quantity", "1"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.modules.#", "1"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.modules.0", "RedisJSON"),
@@ -168,6 +169,7 @@ func TestAccResourceRedisCloudActiveActiveSubscription_CRUDI(t *testing.T) {
 					resource.TestCheckResourceAttr(resourceName, "cloud_provider", "AWS"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.#", "1"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.memory_limit_in_gb", "1"),
+					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.query_performance_factor", "4x"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.quantity", "1"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.modules.#", "1"),
 					resource.TestCheckResourceAttr(resourceName, "creation_plan.0.modules.0", "RedisJSON"),
@@ -335,6 +337,7 @@ resource "rediscloud_active_active_subscription" "example" {
 
 	creation_plan {
 		memory_limit_in_gb = 1
+		query_performance_factor = "2x"
 		modules = ["RedisJSON"]
 		quantity = 1
 		region {

provider/resource_rediscloud_active_active_database.go

@@ -419,6 +419,10 @@ func resourceRedisCloudActiveActiveDatabaseCreate(ctx context.Context, d *schema
 		createDatabase.MemoryLimitInGB = redis.Float64(v.(float64))
 	}
 
+	if v, ok := d.GetOk("query_performance_factor"); ok {
+		createDatabase.QueryPerformanceFactor = redis.String(v.(string))
+	}
+
 	if v, ok := d.GetOk("port"); ok {
 		createDatabase.PortNumber = redis.Int(v.(int))
 	}

provider/resource_rediscloud_active_active_subscription.go

@@ -112,6 +112,11 @@ func resourceRedisCloudActiveActiveSubscription() *schema.Resource {
 							Optional:      true,
 							ConflictsWith: []string{"creation_plan.0.memory_limit_in_gb"},
 						},
+						"query_performance_factor": {
+							Description: "Query performance factor for this specific database",
+							Type:        schema.TypeString,
+							Optional:    true,
+						},
 						"quantity": {
 							Description:  "The planned number of databases",
 							Type:         schema.TypeInt,
@@ -647,14 +652,16 @@ func buildSubscriptionCreatePlanAADatabases(planMap map[string]interface{}) []*s
 		createModules = append(createModules, createModule)
 	}
 
+	queryPerformanceFactor := planMap["queryPerformanceFactor"].(string)
+
 	// create the remaining DBs with all other modules
-	createDatabases = append(createDatabases, createAADatabase(dbName, &idx, localThroughputs, numDatabases, memoryLimitInGB, datasetSizeInGB, createModules)...)
+	createDatabases = append(createDatabases, createAADatabase(dbName, &idx, localThroughputs, numDatabases, memoryLimitInGB, datasetSizeInGB, createModules, queryPerformanceFactor)...)
 
 	return createDatabases
 }
 
 // createDatabase returns a CreateDatabase struct with the given parameters
-func createAADatabase(dbName string, idx *int, localThroughputs []*subscriptions.CreateLocalThroughput, numDatabases int, memoryLimitInGB float64, datasetSizeInGB float64, modules []*subscriptions.CreateModules) []*subscriptions.CreateDatabase {
+func createAADatabase(dbName string, idx *int, localThroughputs []*subscriptions.CreateLocalThroughput, numDatabases int, memoryLimitInGB float64, datasetSizeInGB float64, modules []*subscriptions.CreateModules, queryPerformanceFactor string) []*subscriptions.CreateDatabase {
 	var dbs []*subscriptions.CreateDatabase
 	for i := 0; i < numDatabases; i++ {
 		createDatabase := subscriptions.CreateDatabase{
@@ -663,6 +670,7 @@ func createAADatabase(dbName string, idx *int, localThroughputs []*subscriptions
 			LocalThroughputMeasurement: localThroughputs,
 			Quantity:                   redis.Int(1),
 			Modules:                    modules,
+			QueryPerformanceFactor:     redis.String(queryPerformanceFactor),
 		}
 		if datasetSizeInGB > 0 {
 			createDatabase.DatasetSizeInGB = redis.Float64(datasetSizeInGB)

provider/resource_rediscloud_pro_database.go

@@ -91,6 +91,12 @@ 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,
@@ -341,6 +347,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)
@@ -383,9 +390,10 @@ func resourceRedisCloudProDatabaseCreate(ctx context.Context, d *schema.Resource
 			By:    redis.String(throughputMeasurementBy),
 			Value: redis.Int(throughputMeasurementValue),
 		},
-		Modules:      createModules,
-		Alerts:       createAlerts,
-		RemoteBackup: buildBackupPlan(d.Get("remote_backup").([]interface{}), d.Get("periodic_backup_path")),
+		Modules:                createModules,
+		Alerts:                 createAlerts,
+		RemoteBackup:           buildBackupPlan(d.Get("remote_backup").([]interface{}), d.Get("periodic_backup_path")),
+		QueryPerformanceFactor: redis.String(queryPerformanceFactor),
 	}
 
 	if password != "" {
@@ -659,12 +667,13 @@ func resourceRedisCloudProDatabaseUpdate(ctx context.Context, d *schema.Resource
 			By:    redis.String(d.Get("throughput_measurement_by").(string)),
 			Value: redis.Int(d.Get("throughput_measurement_value").(int)),
 		},
-		DataPersistence:    redis.String(d.Get("data_persistence").(string)),
-		DataEvictionPolicy: redis.String(d.Get("data_eviction").(string)),
-		SourceIP:           setToStringSlice(d.Get("source_ips").(*schema.Set)),
-		Alerts:             &alerts,
-		RemoteBackup:       buildBackupPlan(d.Get("remote_backup").([]interface{}), d.Get("periodic_backup_path")),
-		EnableDefaultUser:  redis.Bool(d.Get("enable_default_user").(bool)),
+		DataPersistence:        redis.String(d.Get("data_persistence").(string)),
+		DataEvictionPolicy:     redis.String(d.Get("data_eviction").(string)),
+		SourceIP:               setToStringSlice(d.Get("source_ips").(*schema.Set)),
+		Alerts:                 &alerts,
+		RemoteBackup:           buildBackupPlan(d.Get("remote_backup").([]interface{}), d.Get("periodic_backup_path")),
+		EnableDefaultUser:      redis.Bool(d.Get("enable_default_user").(bool)),
+		QueryPerformanceFactor: redis.String(d.Get("query_performance_factor").(string)),
 	}
 
 	// One of the following fields must be set, validation is handled in the schema (ExactlyOneOf)

provider/resource_rediscloud_pro_subscription.go

@@ -798,6 +798,11 @@ func buildSubscriptionCreatePlanDatabases(memoryStorage string, planMap map[stri
 		datasetSizeInGB = v.(float64)
 	}
 
+	queryPerformanceFactor := ""
+	if v, ok := planMap["queryPerformanceFactor"]; ok && v != nil {
+		queryPerformanceFactor = v.(string)
+	}
+
 	var diags diag.Diagnostics
 	if memoryStorage == databases.MemoryStorageRam && averageItemSizeInBytes != 0 {
 		// TODO This should be changed to an error when releasing 2.0 of the provider
@@ -824,7 +829,7 @@ func buildSubscriptionCreatePlanDatabases(memoryStorage string, planMap map[stri
 		for _, v := range planModules {
 			modules = append(modules, &subscriptions.CreateModules{Name: v})
 		}
-		createDatabases = append(createDatabases, createDatabase(dbName, &idx, modules, throughputMeasurementBy, throughputMeasurementValue, memoryLimitInGB, datasetSizeInGB, averageItemSizeInBytes, supportOSSClusterAPI, replication, numDatabases)...)
+		createDatabases = append(createDatabases, createDatabase(dbName, &idx, modules, throughputMeasurementBy, throughputMeasurementValue, memoryLimitInGB, datasetSizeInGB, averageItemSizeInBytes, supportOSSClusterAPI, replication, numDatabases, queryPerformanceFactor)...)
 	} else {
 		// make RedisGraph module the first module, then append the rest of the modules
 		var modules []*subscriptions.CreateModules
@@ -835,20 +840,20 @@ func buildSubscriptionCreatePlanDatabases(memoryStorage string, planMap map[stri
 			}
 		}
 		// create a DB with the RedisGraph module
-		createDatabases = append(createDatabases, createDatabase(dbName, &idx, modules[:1], throughputMeasurementBy, throughputMeasurementValue, memoryLimitInGB, datasetSizeInGB, averageItemSizeInBytes, supportOSSClusterAPI, replication, 1)...)
+		createDatabases = append(createDatabases, createDatabase(dbName, &idx, modules[:1], throughputMeasurementBy, throughputMeasurementValue, memoryLimitInGB, datasetSizeInGB, averageItemSizeInBytes, supportOSSClusterAPI, replication, 1, queryPerformanceFactor)...)
 		if numDatabases == 1 {
 			// create one extra DB with all other modules
-			createDatabases = append(createDatabases, createDatabase(dbName, &idx, modules[1:], throughputMeasurementBy, throughputMeasurementValue, memoryLimitInGB, datasetSizeInGB, averageItemSizeInBytes, supportOSSClusterAPI, replication, 1)...)
+			createDatabases = append(createDatabases, createDatabase(dbName, &idx, modules[1:], throughputMeasurementBy, throughputMeasurementValue, memoryLimitInGB, datasetSizeInGB, averageItemSizeInBytes, supportOSSClusterAPI, replication, 1, queryPerformanceFactor)...)
 		} else if numDatabases > 1 {
 			// create the remaining DBs with all other modules
-			createDatabases = append(createDatabases, createDatabase(dbName, &idx, modules[1:], throughputMeasurementBy, throughputMeasurementValue, memoryLimitInGB, datasetSizeInGB, averageItemSizeInBytes, supportOSSClusterAPI, replication, numDatabases-1)...)
+			createDatabases = append(createDatabases, createDatabase(dbName, &idx, modules[1:], throughputMeasurementBy, throughputMeasurementValue, memoryLimitInGB, datasetSizeInGB, averageItemSizeInBytes, supportOSSClusterAPI, replication, numDatabases-1, queryPerformanceFactor)...)
 		}
 	}
 	return createDatabases, diags
 }
 
 // createDatabase returns a CreateDatabase struct with the given parameters
-func createDatabase(dbName string, idx *int, modules []*subscriptions.CreateModules, throughputMeasurementBy string, throughputMeasurementValue int, memoryLimitInGB float64, datasetSizeInGB float64, averageItemSizeInBytes int, supportOSSClusterAPI bool, replication bool, numDatabases int) []*subscriptions.CreateDatabase {
+func createDatabase(dbName string, idx *int, modules []*subscriptions.CreateModules, throughputMeasurementBy string, throughputMeasurementValue int, memoryLimitInGB float64, datasetSizeInGB float64, averageItemSizeInBytes int, supportOSSClusterAPI bool, replication bool, numDatabases int, queryPerformanceFactor string) []*subscriptions.CreateDatabase {
 	createThroughput := &subscriptions.CreateThroughput{
 		By:    redis.String(throughputMeasurementBy),
 		Value: redis.Int(throughputMeasurementValue),
@@ -887,6 +892,11 @@ func createDatabase(dbName string, idx *int, modules []*subscriptions.CreateModu
 		if memoryLimitInGB > 0 {
 			createDatabase.MemoryLimitInGB = redis.Float64(memoryLimitInGB)
 		}
+
+		if queryPerformanceFactor != "" {
+			createDatabase.QueryPerformanceFactor = redis.String(queryPerformanceFactor)
+		}
+
 		*idx++
 		dbs = append(dbs, &createDatabase)
 	}