Merge pull request #640 from RedisLabs/feat/OPCR-17-implement-database-redis-version

OPCR-17 implement database redis version

Author: burythehammer

go.mod

@@ -3,7 +3,7 @@ module github.com/RedisLabs/terraform-provider-rediscloud
 go 1.22.4
 
 require (
-	github.com/RedisLabs/rediscloud-go-api v0.31.0
+	github.com/RedisLabs/rediscloud-go-api v0.32.0
 	github.com/bflad/tfproviderlint v0.31.0
 	github.com/hashicorp/go-cty v1.5.0
 	github.com/hashicorp/terraform-plugin-sdk/v2 v2.36.1

go.sum

@@ -4,8 +4,8 @@ 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.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk=
 github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
-github.com/RedisLabs/rediscloud-go-api v0.31.0 h1:hFdR7nrJcCVQN8h3DeXtP0g4zVQP6X5wtS5FoinG8bo=
-github.com/RedisLabs/rediscloud-go-api v0.31.0/go.mod h1:3/oVb71rv2OstFRYEc65QCIbfwnJTgZeQhtPCcdHook=
+github.com/RedisLabs/rediscloud-go-api v0.32.0 h1:gjOt+8nyMR8MZ5spCz6BXDDdOZrzf7NJJUw4lz8OCGE=
+github.com/RedisLabs/rediscloud-go-api v0.32.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/resource_rediscloud_pro_database.go

@@ -3,6 +3,7 @@ package provider
 import (
 	"context"
 	"fmt"
+	"github.com/RedisLabs/terraform-provider-rediscloud/provider/utils"
 	"regexp"
 	"strconv"
 	"strings"
@@ -235,6 +236,11 @@ func resourceRedisCloudProDatabase() *schema.Resource {
 					return
 				},
 			},
+			"redis_version": {
+				Description: "Defines the Redis database version. If omitted, the Redis version will be set to the default version",
+				Type:        schema.TypeString,
+				Optional:    true,
+			},
 			"modules": {
 				Description: "Modules to be provisioned in the database",
 				Type:        schema.TypeSet,
@@ -346,23 +352,9 @@ func resourceRedisCloudProDatabase() *schema.Resource {
 func resourceRedisCloudProDatabaseCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	api := meta.(*apiClient)
 
-	subId := d.Get("subscription_id").(int)
-
+	subId := *utils.GetInt(d, "subscription_id")
 	subscriptionMutex.Lock(subId)
 
-	name := d.Get("name").(string)
-	protocol := d.Get("protocol").(string)
-	supportOSSClusterAPI := d.Get("support_oss_cluster_api").(bool)
-	respVersion := d.Get("resp_version").(string)
-	dataPersistence := d.Get("data_persistence").(string)
-	dataEviction := d.Get("data_eviction").(string)
-	password := d.Get("password").(string)
-	replication := d.Get("replication").(bool)
-	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)
 	for _, module := range modules.List() {
@@ -394,48 +386,52 @@ func resourceRedisCloudProDatabaseCreate(ctx context.Context, d *schema.Resource
 	}
 
 	createDatabase := databases.CreateDatabase{
-		Name:                 redis.String(name),
-		Protocol:             redis.String(protocol),
-		SupportOSSClusterAPI: redis.Bool(supportOSSClusterAPI),
-		DataPersistence:      redis.String(dataPersistence),
-		DataEvictionPolicy:   redis.String(dataEviction),
-		Replication:          redis.Bool(replication),
+		Name:                 utils.GetString(d, "name"),
+		Protocol:             utils.GetString(d, "protocol"),
+		SupportOSSClusterAPI: utils.GetBool(d, "support_oss_cluster_api"),
+		DataPersistence:      utils.GetString(d, "data_persistence"),
+		DataEvictionPolicy:   utils.GetString(d, "data_eviction"),
+		Replication:          utils.GetBool(d, "replication"),
 		ThroughputMeasurement: &databases.CreateThroughputMeasurement{
-			By:    redis.String(throughputMeasurementBy),
-			Value: redis.Int(throughputMeasurementValue),
+			By:    utils.GetString(d, "throughput_measurement_by"),
+			Value: utils.GetInt(d, "throughput_measurement_value"),
 		},
 		Modules:      createModules,
 		Alerts:       createAlerts,
 		RemoteBackup: buildBackupPlan(d.Get("remote_backup").([]interface{}), d.Get("periodic_backup_path")),
 	}
 
-	if queryPerformanceFactor != "" {
-		createDatabase.QueryPerformanceFactor = redis.String(queryPerformanceFactor)
-	}
+	utils.SetStringIfNotEmpty(d, "query_performance_factor", func(s *string) {
+		createDatabase.QueryPerformanceFactor = s
+	})
 
-	if password != "" {
-		createDatabase.Password = redis.String(password)
-	}
+	utils.SetStringIfNotEmpty(d, "redis_version", func(s *string) {
+		createDatabase.RedisVersion = s
+	})
 
-	if averageItemSizeInBytes > 0 {
-		createDatabase.AverageItemSizeInBytes = &averageItemSizeInBytes
-	}
+	utils.SetStringIfNotEmpty(d, "password", func(s *string) {
+		createDatabase.Password = s
+	})
 
-	if v, ok := d.GetOk("dataset_size_in_gb"); ok {
-		createDatabase.DatasetSizeInGB = redis.Float64(v.(float64))
-	}
+	utils.SetIntIfPositive(d, "average_item_size_in_bytes", func(i *int) {
+		createDatabase.AverageItemSizeInBytes = i
+	})
 
-	if v, ok := d.GetOk("memory_limit_in_gb"); ok {
-		createDatabase.MemoryLimitInGB = redis.Float64(v.(float64))
-	}
+	utils.SetFloat64(d, "dataset_size_in_gb", func(f *float64) {
+		createDatabase.DatasetSizeInGB = f
+	})
 
-	if v, ok := d.GetOk("port"); ok {
-		createDatabase.PortNumber = redis.Int(v.(int))
-	}
+	utils.SetFloat64(d, "memory_limit_in_gb", func(f *float64) {
+		createDatabase.MemoryLimitInGB = f
+	})
 
-	if respVersion != "" {
-		createDatabase.RespVersion = redis.String(respVersion)
-	}
+	utils.SetInt(d, "port", func(i *int) {
+		createDatabase.PortNumber = i
+	})
+
+	utils.SetStringIfNotEmpty(d, "resp_version", func(s *string) {
+		createDatabase.RespVersion = s
+	})
 
 	// Confirm sub is ready to accept a db request
 	if err := waitForSubscriptionToBeActive(ctx, subId, api); err != nil {

provider/utils/utils.go

@@ -0,0 +1,70 @@
+package utils
+
+import (
+	"github.com/RedisLabs/rediscloud-go-api/redis"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+// GetString safely retrieves a string value from schema.ResourceData.
+func GetString(d *schema.ResourceData, key string) *string {
+	if v, ok := d.GetOk(key); ok {
+		return redis.String(v.(string))
+	}
+	return redis.String("")
+}
+
+// GetBool safely retrieves a bool value from schema.ResourceData.
+func GetBool(d *schema.ResourceData, key string) *bool {
+	if v, ok := d.GetOk(key); ok {
+		return redis.Bool(v.(bool))
+	}
+	return redis.Bool(false)
+}
+
+// GetInt safely retrieves an int value from schema.ResourceData.
+func GetInt(d *schema.ResourceData, key string) *int {
+	if v, ok := d.GetOk(key); ok {
+		return redis.Int(v.(int))
+	}
+	return redis.Int(0)
+}
+
+func SetStringIfNotEmpty(d *schema.ResourceData, key string, setter func(*string)) {
+	if v, ok := d.GetOk(key); ok {
+		if s, valid := v.(string); valid && s != "" {
+			setter(redis.String(s))
+		}
+	}
+}
+
+func SetIntIfPositive(d *schema.ResourceData, key string, setter func(*int)) {
+	if v, ok := d.GetOk(key); ok {
+		if i, valid := v.(int); valid && i > 0 {
+			setter(redis.Int(i))
+		}
+	}
+}
+
+func SetInt(d *schema.ResourceData, key string, setter func(*int)) {
+	if v, ok := d.GetOk(key); ok {
+		if i, valid := v.(int); valid {
+			setter(redis.Int(i))
+		}
+	}
+}
+
+func SetFloat64(d *schema.ResourceData, key string, setter func(*float64)) {
+	if v, ok := d.GetOk(key); ok {
+		if f, valid := v.(float64); valid {
+			setter(redis.Float64(f))
+		}
+	}
+}
+
+func SetBool(d *schema.ResourceData, key string, setter func(*bool)) {
+	if v, ok := d.GetOk(key); ok {
+		if b, valid := v.(bool); valid {
+			setter(redis.Bool(b))
+		}
+	}
+}