add final_backup_config field to google_sql_database_instance (#14891) (#10678)

[upstream:defbc8d07bc1c0e896471cb81036571b1f1c6870]

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

Author: modular-magician

.changelog/14891.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+sql: add `final_backup_description` and `final_backup_config` fields to `google_sql_database_instance` resource
+```

google-beta/services/sql/resource_sql_database_instance.go

@@ -188,6 +188,11 @@ func ResourceSqlDatabaseInstance() *schema.Resource {
 				Optional:    true,
 				Description: `Used to block Terraform from deleting a SQL Instance. Defaults to true.`,
 			},
+			"final_backup_description": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: `The description of final backup if instance enable create final backup during instance deletion. `,
+			},
 			"settings": {
 				Type:         schema.TypeList,
 				Optional:     true,
@@ -806,6 +811,27 @@ API (for read pools, effective_availability_type may differ from availability_ty
 							Optional:    true,
 							Description: `When this parameter is set to true, Cloud SQL retains backups of the instance even after the instance is deleted. The ON_DEMAND backup will be retained until customer deletes the backup or the project. The AUTOMATED backup will be retained based on the backups retention setting.`,
 						},
+						"final_backup_config": {
+							Type:     schema.TypeList,
+							Optional: true,
+							MaxItems: 1,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"enabled": {
+										Type:        schema.TypeBool,
+										Optional:    true,
+										Description: `When this parameter is set to true, the final backup is enabled for the instance`,
+									},
+									"retention_days": {
+										Type:         schema.TypeInt,
+										Optional:     true,
+										ValidateFunc: validation.IntBetween(1, 36135),
+										Description:  `The number of days to retain the final backup after the instance deletion. The valid range is between 1 and 365. For instances managed by BackupDR, the valid range is between 1 day and 99 years. The final backup will be purged at (time_of_instance_deletion + retention_days).`,
+									},
+								},
+							},
+							Description: `Config used to determine the final backup settings for the instance`,
+						},
 					},
 				},
 				Description: `The settings to use for the database. The configuration is detailed below.`,
@@ -1518,6 +1544,7 @@ func expandSqlDatabaseInstanceSettings(configured []interface{}, databaseVersion
 		EnableGoogleMlIntegration:     _settings["enable_google_ml_integration"].(bool),
 		EnableDataplexIntegration:     _settings["enable_dataplex_integration"].(bool),
 		RetainBackupsOnDelete:         _settings["retain_backups_on_delete"].(bool),
+		FinalBackupConfig:             expandFinalBackupConfig(_settings["final_backup_config"].([]interface{})),
 		UserLabels:                    tpgresource.ConvertStringMap(_settings["user_labels"].(map[string]interface{})),
 		BackupConfiguration:           expandBackupConfiguration(_settings["backup_configuration"].([]interface{})),
 		DatabaseFlags:                 expandDatabaseFlags(_settings["database_flags"].(*schema.Set).List()),
@@ -1760,6 +1787,19 @@ func expandBackupConfiguration(configured []interface{}) *sqladmin.BackupConfigu
 	}
 }
 
+func expandFinalBackupConfig(configured []interface{}) *sqladmin.FinalBackupConfig {
+	if len(configured) == 0 || configured[0] == nil {
+		return nil
+	}
+
+	_finalBackupConfig := configured[0].(map[string]interface{})
+	return &sqladmin.FinalBackupConfig{
+		Enabled:         _finalBackupConfig["enabled"].(bool),
+		RetentionDays:   int64(_finalBackupConfig["retention_days"].(int)),
+		ForceSendFields: []string{"Enabled"},
+	}
+}
+
 func expandBackupRetentionSettings(configured interface{}) *sqladmin.BackupRetentionSettings {
 	l := configured.([]interface{})
 	if len(l) == 0 {
@@ -2388,9 +2428,13 @@ func resourceSqlDatabaseInstanceDelete(d *schema.ResourceData, meta interface{})
 	}
 
 	var op *sqladmin.Operation
+	finalBackupDescription := ""
+	if v, ok := d.GetOk("finalBackupDescription"); ok {
+		finalBackupDescription = v.(string)
+	}
 	err = transport_tpg.Retry(transport_tpg.RetryOptions{
 		RetryFunc: func() (rerr error) {
-			op, rerr = config.NewSqlAdminClient(userAgent).Instances.Delete(project, d.Get("name").(string)).Do()
+			op, rerr = config.NewSqlAdminClient(userAgent).Instances.Delete(project, d.Get("name").(string)).FinalBackupDescription(finalBackupDescription).Do()
 			if rerr != nil {
 				return rerr
 			}
@@ -2452,6 +2496,7 @@ func flattenSettings(settings *sqladmin.Settings, iType string, d *schema.Resour
 		"time_zone":                        settings.TimeZone,
 		"deletion_protection_enabled":      settings.DeletionProtectionEnabled,
 		"retain_backups_on_delete":         settings.RetainBackupsOnDelete,
+		"final_backup_config":              settings.FinalBackupConfig,
 	}
 
 	if data["availability_type"] == "" {
@@ -2482,6 +2527,10 @@ func flattenSettings(settings *sqladmin.Settings, iType string, d *schema.Resour
 		data["backup_configuration"] = flattenBackupConfiguration(settings.BackupConfiguration)
 	}
 
+	if settings.FinalBackupConfig != nil {
+		data["final_backup_config"] = flattenFinalBackupConfig(settings.FinalBackupConfig)
+	}
+
 	if settings.DatabaseFlags != nil {
 		data["database_flags"] = flattenDatabaseFlags(settings.DatabaseFlags)
 	}
@@ -2566,6 +2615,15 @@ func flattenBackupConfiguration(backupConfiguration *sqladmin.BackupConfiguratio
 	return []map[string]interface{}{data}
 }
 
+func flattenFinalBackupConfig(finalBackupConfig *sqladmin.FinalBackupConfig) []map[string]interface{} {
+	data := map[string]interface{}{
+		"enabled":        finalBackupConfig.Enabled,
+		"retention_days": finalBackupConfig.RetentionDays,
+	}
+
+	return []map[string]interface{}{data}
+}
+
 func flattenBackupRetentionSettings(b *sqladmin.BackupRetentionSettings) []map[string]interface{} {
 	if b == nil {
 		return nil

google-beta/services/sql/resource_sql_database_instance_test.go

@@ -1708,6 +1708,38 @@ func TestAccSqlDatabaseInstance_RetainBackupOnDelete(t *testing.T) {
 	})
 }
 
+func TestAccSqlDatabaseInstance_FinalBackupConfig(t *testing.T) {
+	t.Parallel()
+
+	masterID := acctest.RandInt(t)
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testGoogleSqlDatabaseInstance_FinalBackupConfig(masterID, true, 10),
+			},
+			{
+				ResourceName:            "google_sql_database_instance.instance",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"deletion_protection", "final_backup_description"},
+			},
+			{
+				Config: testGoogleSqlDatabaseInstance_FinalBackupConfig(masterID, false, -1),
+			},
+			{
+				ResourceName:            "google_sql_database_instance.instance",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"deletion_protection", "final_backup_description"},
+			},
+		},
+	})
+}
+
 func TestAccSqlDatabaseInstance_PointInTimeRecoveryEnabled(t *testing.T) {
 	t.Parallel()
 
@@ -6437,6 +6469,47 @@ resource "google_sql_database_instance" "instance" {
 `, masterID, retainBackupOnDelete)
 }
 
+func testGoogleSqlDatabaseInstance_FinalBackupConfig(masterID int, enabled bool, retention_days int64) string {
+	retentionSetting := ""
+	if retention_days >= 0 {
+		retentionSetting = fmt.Sprintf(`retention_days = %d`, retention_days)
+	}
+
+	finalBackupConfig := fmt.Sprintf(`final_backup_config {
+		enabled = %v
+		%v
+	}`, enabled, retentionSetting)
+
+	finalBackupDescription := `""`
+	if enabled {
+		finalBackupDescription = `"Test FinalBackup Description"`
+	}
+
+	return fmt.Sprintf(`
+resource "google_sql_database_instance" "instance" {
+  name                = "tf-test-%d"
+  region              = "us-central1"
+  database_version    = "MYSQL_8_0"
+  deletion_protection = false
+  final_backup_description = %v
+
+  settings {
+    tier = "db-g1-small"
+    backup_configuration {
+      enabled                        = true
+      start_time                     = "00:00"
+      binary_log_enabled             = true
+	  transaction_log_retention_days = 2
+	  backup_retention_settings {
+	    retained_backups = 4
+	  }
+    }
+%v
+  }
+}
+`, masterID, finalBackupDescription, finalBackupConfig)
+}
+
 func testAccSqlDatabaseInstance_beforeBackup(context map[string]interface{}) string {
 	return acctest.Nprintf(`
 resource "google_sql_database_instance" "instance" {

website/docs/r/sql_database_instance.html.markdown

@@ -341,6 +341,8 @@ includes an up-to-date reference of supported versions.
     or `terraform destroy` that would delete the instance will fail.
     When the field is set to false, deleting the instance is allowed.
 
+* `final_backup_description` - (Optional) The description of final backup. Only set this field when `final_backup_config.enabled` is true.
+
   ~> **NOTE:** This flag only protects instances from deletion within Terraform. To protect your instances from accidental deletion across all surfaces (API, gcloud, Cloud Console and Terraform), use the API flag `settings.deletion_protection_enabled`.
 
 * `restore_backup_context` - (optional) The context needed to restore the database to a backup run. This field will
@@ -409,6 +411,12 @@ The `settings` block supports:
 
 * `retain_backups_on_delete` - (Optional) When this parameter is set to true, Cloud SQL retains backups of the instance even after the instance is deleted. The `ON_DEMAND` backup will be retained until customer deletes the backup or the project. The `AUTOMATED` backup will be retained based on the backups retention setting.
 
+The optional `final_backup_config` subblock supports:
+
+* `enabled` - (Optional) True if enabled final backup.
+
+* `retention_days` - (Optional) The number of days we retain the final backup after instance deletion. The valid range is between 1 and 365. For instances managed by BackupDR, the valid range is between 1 day and 99 years.
+
 The optional `settings.advanced_machine_features` subblock supports:
 
 * `threads_per_core` - (Optional) The number of threads per core. The value of this flag can be 1 or 2. To disable SMT, set this flag to 1. Only available in Cloud SQL for SQL Server instances. See [smt](https://cloud.google.com/sql/docs/sqlserver/create-instance#smt-create-instance) for more details.