Adding automated backup config to Redis (#13401) (#22117)

[upstream:3ba9ffacd77872416e7a528289c4137fb09f40a4]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/13401.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+redis: added `automated_backup_config` field to `google_redis_cluster`
+```

google/services/redis/resource_redis_cluster.go

@@ -80,6 +80,50 @@ projects/{projectId}/locations/{locationId}/clusters/{clusterId}`,
 				Description:  `Optional. The authorization mode of the Redis cluster. If not provided, auth feature is disabled for the cluster. Default value: "AUTH_MODE_DISABLED" Possible values: ["AUTH_MODE_UNSPECIFIED", "AUTH_MODE_IAM_AUTH", "AUTH_MODE_DISABLED"]`,
 				Default:      "AUTH_MODE_DISABLED",
 			},
+			"automated_backup_config": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Description: `The automated backup config for a instance.`,
+				MaxItems:    1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"fixed_frequency_schedule": {
+							Type:        schema.TypeList,
+							Required:    true,
+							Description: `Trigger automated backups at a fixed frequency.`,
+							MaxItems:    1,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"start_time": {
+										Type:     schema.TypeList,
+										Required: true,
+										Description: `The start time of every automated backup in UTC.
+It must be set to the start of an hour. This field is required.`,
+										MaxItems: 1,
+										Elem: &schema.Resource{
+											Schema: map[string]*schema.Schema{
+												"hours": {
+													Type:     schema.TypeInt,
+													Required: true,
+													Description: `Hours of a day in 24 hour format. Must be greater than or equal to 0 and typically must be less than or equal to 23.
+An API may choose to allow the value "24:00:00" for scenarios like business closing time.`,
+												},
+											},
+										},
+									},
+								},
+							},
+						},
+						"retention": {
+							Type:     schema.TypeString,
+							Required: true,
+							Description: `How long to keep automated backups before the backups are deleted.
+The value should be between 1 day and 365 days. If not specified, the default value is 35 days.
+A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".`,
+						},
+					},
+				},
+			},
 			"cross_cluster_replication_config": {
 				Type:        schema.TypeList,
 				Computed:    true,
@@ -656,6 +700,12 @@ func resourceRedisClusterCreate(d *schema.ResourceData, meta interface{}) error
 	}
 
 	obj := make(map[string]interface{})
+	automatedBackupConfigProp, err := expandRedisClusterAutomatedBackupConfig(d.Get("automated_backup_config"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("automated_backup_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(automatedBackupConfigProp)) && (ok || !reflect.DeepEqual(v, automatedBackupConfigProp)) {
+		obj["automatedBackupConfig"] = automatedBackupConfigProp
+	}
 	authorizationModeProp, err := expandRedisClusterAuthorizationMode(d.Get("authorization_mode"), d, config)
 	if err != nil {
 		return err
@@ -735,6 +785,11 @@ func resourceRedisClusterCreate(d *schema.ResourceData, meta interface{}) error
 		obj["kmsKey"] = kmsKeyProp
 	}
 
+	obj, err = resourceRedisClusterEncoder(d, meta, obj)
+	if err != nil {
+		return err
+	}
+
 	url, err := tpgresource.ReplaceVars(d, config, "{{RedisBasePath}}projects/{{project}}/locations/{{region}}/clusters?clusterId={{name}}")
 	if err != nil {
 		return err
@@ -850,6 +905,9 @@ func resourceRedisClusterRead(d *schema.ResourceData, meta interface{}) error {
 	if err := d.Set("uid", flattenRedisClusterUid(res["uid"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Cluster: %s", err)
 	}
+	if err := d.Set("automated_backup_config", flattenRedisClusterAutomatedBackupConfig(res["automatedBackupConfig"], d, config)); err != nil {
+		return fmt.Errorf("Error reading Cluster: %s", err)
+	}
 	if err := d.Set("authorization_mode", flattenRedisClusterAuthorizationMode(res["authorizationMode"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Cluster: %s", err)
 	}
@@ -927,6 +985,12 @@ func resourceRedisClusterUpdate(d *schema.ResourceData, meta interface{}) error
 	billingProject = project
 
 	obj := make(map[string]interface{})
+	automatedBackupConfigProp, err := expandRedisClusterAutomatedBackupConfig(d.Get("automated_backup_config"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("automated_backup_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, automatedBackupConfigProp)) {
+		obj["automatedBackupConfig"] = automatedBackupConfigProp
+	}
 	nodeTypeProp, err := expandRedisClusterNodeType(d.Get("node_type"), d, config)
 	if err != nil {
 		return err
@@ -988,6 +1052,11 @@ func resourceRedisClusterUpdate(d *schema.ResourceData, meta interface{}) error
 		obj["kmsKey"] = kmsKeyProp
 	}
 
+	obj, err = resourceRedisClusterEncoder(d, meta, obj)
+	if err != nil {
+		return err
+	}
+
 	url, err := tpgresource.ReplaceVars(d, config, "{{RedisBasePath}}projects/{{project}}/locations/{{region}}/clusters/{{name}}")
 	if err != nil {
 		return err
@@ -997,6 +1066,10 @@ func resourceRedisClusterUpdate(d *schema.ResourceData, meta interface{}) error
 	headers := make(http.Header)
 	updateMask := []string{}
 
+	if d.HasChange("automated_backup_config") {
+		updateMask = append(updateMask, "automatedBackupConfig")
+	}
+
 	if d.HasChange("node_type") {
 		updateMask = append(updateMask, "nodeType")
 	}
@@ -1168,6 +1241,72 @@ func flattenRedisClusterUid(v interface{}, d *schema.ResourceData, config *trans
 	return v
 }
 
+func flattenRedisClusterAutomatedBackupConfig(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return nil
+	}
+	original := v.(map[string]interface{})
+	if len(original) == 0 {
+		return nil
+	}
+	// if automated_backup_config is not defined
+	if original["automatedBackupMode"] == "DISABLED" {
+		return nil
+	}
+	transformed := make(map[string]interface{})
+	transformed["fixed_frequency_schedule"] =
+		flattenRedisClusterAutomatedBackupConfigFixedFrequencySchedule(original["fixedFrequencySchedule"], d, config)
+	transformed["retention"] =
+		flattenRedisClusterAutomatedBackupConfigRetention(original["retention"], d, config)
+	return []interface{}{transformed}
+}
+func flattenRedisClusterAutomatedBackupConfigFixedFrequencySchedule(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return nil
+	}
+	original := v.(map[string]interface{})
+	if len(original) == 0 {
+		return nil
+	}
+	transformed := make(map[string]interface{})
+	transformed["start_time"] =
+		flattenRedisClusterAutomatedBackupConfigFixedFrequencyScheduleStartTime(original["startTime"], d, config)
+	return []interface{}{transformed}
+}
+func flattenRedisClusterAutomatedBackupConfigFixedFrequencyScheduleStartTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return nil
+	}
+	original := v.(map[string]interface{})
+	if len(original) == 0 {
+		return nil
+	}
+	transformed := make(map[string]interface{})
+	transformed["hours"] =
+		flattenRedisClusterAutomatedBackupConfigFixedFrequencyScheduleStartTimeHours(original["hours"], d, config)
+	return []interface{}{transformed}
+}
+func flattenRedisClusterAutomatedBackupConfigFixedFrequencyScheduleStartTimeHours(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	// Handles the string fixed64 format
+	if strVal, ok := v.(string); ok {
+		if intVal, err := tpgresource.StringToFixed64(strVal); err == nil {
+			return intVal
+		}
+	}
+
+	// number values are represented as float64
+	if floatVal, ok := v.(float64); ok {
+		intVal := int(floatVal)
+		return intVal
+	}
+
+	return v // let terraform core handle it otherwise
+}
+
+func flattenRedisClusterAutomatedBackupConfigRetention(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenRedisClusterAuthorizationMode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	return v
 }
@@ -1830,6 +1969,85 @@ func flattenRedisClusterKmsKey(v interface{}, d *schema.ResourceData, config *tr
 	return v
 }
 
+func expandRedisClusterAutomatedBackupConfig(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	l := v.([]interface{})
+	if len(l) == 0 || l[0] == nil {
+		return nil, nil
+	}
+	raw := l[0]
+	original := raw.(map[string]interface{})
+	// The automated_backup_config block is not specified, so automatedBackupMode should be DISABLED
+	transformed := make(map[string]interface{})
+	if len(d.Get("automated_backup_config").([]interface{})) < 1 {
+		transformed["automatedBackupMode"] = "DISABLED"
+		return transformed, nil
+	}
+
+	// The automated_backup_config block is specified, so automatedBackupMode should be ENALBED
+	transformed["automatedBackupMode"] = "ENABLED"
+	transformedFixedFrequencySchedule, err := expandRedisClusterAutomatedBackupConfigFixedFrequencySchedule(original["fixed_frequency_schedule"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedFixedFrequencySchedule); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["fixedFrequencySchedule"] = transformedFixedFrequencySchedule
+	}
+
+	transformedRetention, err := expandRedisClusterAutomatedBackupConfigRetention(original["retention"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedRetention); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["retention"] = transformedRetention
+	}
+
+	return transformed, nil
+}
+
+func expandRedisClusterAutomatedBackupConfigFixedFrequencySchedule(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	l := v.([]interface{})
+	if len(l) == 0 || l[0] == nil {
+		return nil, nil
+	}
+	raw := l[0]
+	original := raw.(map[string]interface{})
+	transformed := make(map[string]interface{})
+
+	transformedStartTime, err := expandRedisClusterAutomatedBackupConfigFixedFrequencyScheduleStartTime(original["start_time"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedStartTime); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["startTime"] = transformedStartTime
+	}
+
+	return transformed, nil
+}
+
+func expandRedisClusterAutomatedBackupConfigFixedFrequencyScheduleStartTime(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	l := v.([]interface{})
+	if len(l) == 0 || l[0] == nil {
+		return nil, nil
+	}
+	raw := l[0]
+	original := raw.(map[string]interface{})
+	transformed := make(map[string]interface{})
+
+	transformedHours, err := expandRedisClusterAutomatedBackupConfigFixedFrequencyScheduleStartTimeHours(original["hours"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedHours); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["hours"] = transformedHours
+	}
+
+	return transformed, nil
+}
+
+func expandRedisClusterAutomatedBackupConfigFixedFrequencyScheduleStartTimeHours(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandRedisClusterAutomatedBackupConfigRetention(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandRedisClusterAuthorizationMode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }
@@ -2391,3 +2609,15 @@ func expandRedisClusterCrossClusterReplicationConfigUpdateTime(v interface{}, d
 func expandRedisClusterKmsKey(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }
+
+func resourceRedisClusterEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) {
+
+	// if the automated_backup_config is not defined, automatedBackupMode needs to be passed and set to DISABLED in the expand
+	if obj["automatedBackupConfig"] == nil {
+		config := meta.(*transport_tpg.Config)
+		automatedBackupConfigProp, _ := expandRedisClusterAutomatedBackupConfig(d.Get("automated_backup_config"), d, config)
+		obj["automatedBackupConfig"] = automatedBackupConfigProp
+	}
+
+	return obj, nil
+}

google/services/redis/resource_redis_cluster_generated_meta.yaml

@@ -6,6 +6,8 @@ api_version: 'v1'
 api_resource_type_kind: 'Cluster'
 fields:
   - field: 'authorization_mode'
+  - field: 'automated_backup_config.fixed_frequency_schedule.start_time.hours'
+  - field: 'automated_backup_config.retention'
   - field: 'create_time'
   - field: 'cross_cluster_replication_config.cluster_role'
   - field: 'cross_cluster_replication_config.membership.primary_cluster.cluster'

google/services/redis/resource_redis_cluster_test.go

@@ -1,3 +1,74 @@
 // Copyright (c) HashiCorp, Inc.
 // SPDX-License-Identifier: MPL-2.0
 package redis_test
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-provider-google/google/acctest"
+)
+
+func TestAccRedisCluster_automatedBackupConfig(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"random_suffix": acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckRedisClusterDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccRedisCluster_automatedBackupConfig(context),
+			},
+			{
+				ResourceName:      "google_redis_cluster.cluster_abc",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccRedisCluster_automatedBackupConfigWithout(context),
+			},
+			{
+				ResourceName:      "google_redis_cluster.cluster_abc",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
+func testAccRedisCluster_automatedBackupConfig(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_redis_cluster" "cluster_abc" {
+  name                           = "tf-test-redis-abc-%{random_suffix}"
+  shard_count                    = 1
+  region                         = "us-central1"
+  deletion_protection_enabled    = false
+  automated_backup_config {
+   retention                     = "259200s"
+   fixed_frequency_schedule {
+    start_time {
+      hours                      = 20
+    }
+   }
+  }
+
+}	
+`, context)
+}
+
+func testAccRedisCluster_automatedBackupConfigWithout(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_redis_cluster" "cluster_abc" {
+  name                           = "tf-test-redis-abc-%{random_suffix}"
+  shard_count                    = 1
+  region                         = "us-central1"
+  deletion_protection_enabled    = false 
+  
+}	
+`, context)
+}