feat: essentials database version support

Author: burythehammer

docs/data-sources/rediscloud_essentials_database.md

@@ -39,6 +39,7 @@ data "rediscloud_essentials_database" "example" {
 ## Attribute Reference
 
 * `protocol` - The protocol of the database. Either `redis`, `memcached` or `stack`.
+* `redis_version` - The Redis database version.
 * `cloud_provider` - The Cloud Provider hosting this database.
 * `region` - The region within the Cloud Provider where this database is hosted.
 * `redis_version_compliance` - The compliance level (redis version) of this database.

docs/resources/rediscloud_essentials_database.md

@@ -58,6 +58,7 @@ The following arguments are supported:
 * `subscription_id` - (Required) The ID of the subscription to create the database in. **Modifying this attribute will force creation of a new resource.**
 * `name` - (Required) A meaningful name to identify the database.
 * `protocol` - (Optional) Database protocol. 'stack' is a suite of all Redis' data modules. Default: 'stack'. Either: 'redis', 'memcached' or 'stack'. **'redis' is only used with Pay-As-You-Go databases.**
+* `redis_version` - (Optional) Defines the Redis database version. If omitted, the Redis version will be set to the default version.
 * `resp_version` - (Optional) RESP version must be compatible with the Redis version.
 * `data_persistence` - (Required) Rate of database data persistence (in persistent storage). Either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'.
 * `data_eviction` - (Optional) Data items eviction method. Either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'. Default: 'volatile-lru'.

provider/essentials/testdata/essentials_database_basic.tf

@@ -0,0 +1,52 @@
+terraform {
+  required_providers {
+    rediscloud = {
+      source = "RedisLabs/rediscloud"
+    }
+  }
+}
+
+variable "subscription_id" {
+  type = number
+}
+
+variable "database_name" {
+  type = string
+}
+
+variable "redis_version" {
+  type = string
+}
+
+variable "password" {
+  type      = string
+  sensitive = true
+}
+
+resource "rediscloud_essentials_database" "example" {
+  subscription_id = var.subscription_id
+  name            = var.database_name
+  protocol        = "redis"
+  redis_version   = var.redis_version
+  replication     = false
+  data_persistence = "none"
+
+  password = var.password
+
+  alert {
+    name  = "throughput-higher-than"
+    value = 80
+  }
+}
+
+output "database_id" {
+  value = rediscloud_essentials_database.example.db_id
+}
+
+output "redis_version" {
+  value = rediscloud_essentials_database.example.redis_version
+}
+
+output "public_endpoint" {
+  value = rediscloud_essentials_database.example.public_endpoint
+}

provider/essentials/testdata/essentials_database_updated_version.tf

@@ -0,0 +1,52 @@
+terraform {
+  required_providers {
+    rediscloud = {
+      source = "RedisLabs/rediscloud"
+    }
+  }
+}
+
+variable "subscription_id" {
+  type = number
+}
+
+variable "database_name" {
+  type = string
+}
+
+variable "redis_version" {
+  type = string
+}
+
+variable "password" {
+  type      = string
+  sensitive = true
+}
+
+resource "rediscloud_essentials_database" "example" {
+  subscription_id = var.subscription_id
+  name            = var.database_name
+  protocol        = "redis"
+  redis_version   = var.redis_version  # This will be updated during test
+  replication     = false
+  data_persistence = "aof-every-write"
+
+  password = var.password
+
+  alert {
+    name  = "throughput-higher-than"
+    value = 85
+  }
+}
+
+output "database_id" {
+  value = rediscloud_essentials_database.example.db_id
+}
+
+output "redis_version" {
+  value = rediscloud_essentials_database.example.redis_version
+}
+
+output "public_endpoint" {
+  value = rediscloud_essentials_database.example.public_endpoint
+}

provider/resource_rediscloud_essentials_database.go

@@ -76,6 +76,12 @@ func resourceRedisCloudEssentialsDatabase() *schema.Resource {
 				Computed:         true,
 				ForceNew:         true,
 			},
+			"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,
+				Computed:    true,
+			},
 			"cloud_provider": {
 				Description: "The Cloud Provider hosting this database",
 				Type:        schema.TypeString,
@@ -319,6 +325,10 @@ func resourceRedisCloudEssentialsDatabaseCreate(ctx context.Context, d *schema.R
 		createDatabaseRequest.Protocol = redis.String(protocol)
 	}
 
+	utils.SetStringIfNotEmpty(d, "redis_version", func(s *string) {
+		createDatabaseRequest.RedisVersion = s
+	})
+
 	respVersion := d.Get("resp_version").(string)
 	if respVersion != "" {
 		createDatabaseRequest.RespVersion = redis.String(respVersion)
@@ -466,6 +476,9 @@ func resourceRedisCloudEssentialsDatabaseRead(ctx context.Context, d *schema.Res
 	if err := d.Set("protocol", redis.StringValue(db.Protocol)); err != nil {
 		return diag.FromErr(err)
 	}
+	if err := d.Set("redis_version", redis.StringValue(db.RedisVersion)); err != nil {
+		return diag.FromErr(err)
+	}
 	if err := d.Set("cloud_provider", redis.StringValue(db.Provider)); err != nil {
 		return diag.FromErr(err)
 	}
@@ -599,6 +612,23 @@ func resourceRedisCloudEssentialsDatabaseUpdate(ctx context.Context, d *schema.R
 	utils.SubscriptionMutex.Lock(subId)
 	defer utils.SubscriptionMutex.Unlock(subId)
 
+	// Handle redis_version upgrades before other updates
+	if d.HasChange("redis_version") {
+		originalVersion, newVersion := d.GetChange("redis_version")
+
+		// Only perform upgrade if both versions are non-empty (prevents unnecessary upgrades on creation)
+		if originalVersion.(string) != "" && newVersion.(string) != "" {
+			if upgradeDiags, unlocked := upgradeRedisVersionEssentials(ctx, api, subId, databaseId, newVersion.(string)); upgradeDiags != nil {
+				if !unlocked {
+					utils.SubscriptionMutex.Unlock(subId)
+				}
+				return append(diag.Diagnostics{}, upgradeDiags...)
+			}
+			// Lock again since the upgrade function unlocked it
+			utils.SubscriptionMutex.Lock(subId)
+		}
+	}
+
 	updateDatabaseRequest := fixedDatabases.UpdateFixedDatabase{
 		Name:               redis.String(d.Get("name").(string)),
 		DataPersistence:    redis.String(d.Get("data_persistence").(string)),
@@ -734,6 +764,35 @@ func resourceRedisCloudEssentialsDatabaseDelete(ctx context.Context, d *schema.R
 	return diags
 }
 
+func upgradeRedisVersionEssentials(ctx context.Context, api *client.ApiClient, subId int, dbId int, newVersion string) (diag.Diagnostics, bool) {
+	log.Printf("[INFO] Requesting Redis version change to %s...", newVersion)
+
+	upgrade := fixedDatabases.UpgradeRedisVersion{
+		TargetRedisVersion: redis.String(newVersion),
+	}
+
+	if err := api.Client.FixedDatabases.UpgradeRedisVersion(ctx, subId, dbId, upgrade); err != nil {
+		utils.SubscriptionMutex.Unlock(subId)
+		return diag.Errorf("failed to change Redis version to %s: %v", newVersion, err), true
+	}
+
+	log.Printf("[INFO] Redis version change request to %s accepted by API", newVersion)
+
+	// Wait for database to be active
+	if err := waitForEssentialsDatabaseToBeActive(ctx, subId, dbId, api); err != nil {
+		utils.SubscriptionMutex.Unlock(subId)
+		return diag.FromErr(err), true
+	}
+
+	// Wait for subscription to be active
+	if err := waitForEssentialsSubscriptionToBeActive(ctx, subId, api); err != nil {
+		utils.SubscriptionMutex.Unlock(subId)
+		return diag.FromErr(err), true
+	}
+
+	return nil, false
+}
+
 func waitForEssentialsDatabaseToBeActive(ctx context.Context, subId, id int, api *client.ApiClient) error {
 	wait := &retry.StateChangeConf{
 		Delay: 30 * time.Second,
@@ -771,6 +830,7 @@ func waitForEssentialsDatabaseToBeActive(ctx context.Context, subId, id int, api
 	return nil
 }
 
+
 func writeReplica(replica fixedDatabases.ReplicaOf) []map[string]interface{} {
 	tf := map[string]interface{}{}
 	syncSources := make([]map[string]interface{}, 0)

provider/resource_rediscloud_essentials_database_test.go

@@ -334,6 +334,40 @@ func TestAccResourceRedisCloudEssentialsDatabase_DisableDefaultUser(t *testing.T
 	})
 }
 
+// Test redis_version field support - ensures version can be specified and read
+func TestAccResourceRedisCloudEssentialsDatabase_RedisVersion(t *testing.T) {
+	utils.AccRequiresEnvVar(t, "EXECUTE_TESTS")
+
+	subscriptionName := acctest.RandomWithPrefix(testResourcePrefix)
+	databaseName := subscriptionName + "-db"
+
+	const resourceName = "rediscloud_essentials_database.example"
+	const datasourceName = "data.rediscloud_essentials_database.example"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: providerFactories,
+		CheckDestroy:      testAccCheckEssentialsSubscriptionDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: fmt.Sprintf(testAccResourceRedisCloudEssentialsDatabaseRedisVersion, subscriptionName, databaseName),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					// Test the resource has redis_version set
+					resource.TestMatchResourceAttr(resourceName, "id", regexp.MustCompile("^\\d+/\\d+$")),
+					resource.TestCheckResourceAttrSet(resourceName, "subscription_id"),
+					resource.TestCheckResourceAttrSet(resourceName, "db_id"),
+					resource.TestCheckResourceAttr(resourceName, "name", databaseName),
+					resource.TestCheckResourceAttrSet(resourceName, "redis_version"),
+
+					// Test the datasource also returns redis_version
+					resource.TestMatchResourceAttr(datasourceName, "id", regexp.MustCompile("^\\d+/\\d+$")),
+					resource.TestCheckResourceAttrSet(datasourceName, "redis_version"),
+				),
+			},
+		},
+	})
+}
+
 const testAccResourceRedisCloudEssentialsDatabaseDisableDefaultUserCreate = `
 
 data "rediscloud_payment_method" "card" {
@@ -417,3 +451,43 @@ resource "rediscloud_essentials_database" "example" {
   }
 }
 `
+
+const testAccResourceRedisCloudEssentialsDatabaseRedisVersion = `
+
+data "rediscloud_payment_method" "card" {
+	card_type = "Visa"
+	last_four_numbers = "5556"
+}
+
+data "rediscloud_essentials_plan" "example" {
+  name = "Single-Zone_1GB"
+  cloud_provider = "AWS"
+  region = "us-east-1"
+}
+
+data "rediscloud_essentials_database" "example" {
+	subscription_id = rediscloud_essentials_subscription.example.id
+	name = rediscloud_essentials_database.example.name
+}
+
+resource "rediscloud_essentials_subscription" "example" {
+  name = "%s"
+  plan_id = data.rediscloud_essentials_plan.example.id
+  payment_method_id = data.rediscloud_payment_method.card.id
+}
+
+resource "rediscloud_essentials_database" "example" {
+  subscription_id     = rediscloud_essentials_subscription.example.id
+  name                = "%s"
+  enable_default_user = true
+  password            = "j43589rhe39f"
+
+  data_persistence = "none"
+  replication      = false
+
+  alert {
+    name  = "throughput-higher-than"
+    value = 80
+  }
+}
+`