Added - Support for ADB-S: Long-Term Automatic Backup Retention

Author: Terraform Team Automation

internal/integrationtest/database_autonomous_database_backup_test.go

@@ -779,10 +779,9 @@ func TestDatabaseAutonomousDatabaseResource_basic(t *testing.T) {
 				resource.TestCheckResourceAttrSet(datasourceName, "autonomous_databases.0.is_refreshable_clone"),
 				resource.TestCheckResourceAttrSet(datasourceName, "autonomous_databases.0.kms_key_id"),
 				resource.TestCheckResourceAttr(datasourceName, "autonomous_databases.0.license_model", "LICENSE_INCLUDED"),
-				// memory_per_oracle_compute_unit_in_gbs is used by only Exacc at the moment
-				//resource.TestCheckResourceAttrSet(datasourceName, "autonomous_databases.0.memory_per_oracle_compute_unit_in_gbs"),
-				//resource.TestCheckResourceAttr(datasourceName, "autonomous_databases.0.ocpu_count", 1.1),
 				resource.TestCheckResourceAttr(datasourceName, "autonomous_databases.0.max_cpu_core_count", "3"),
+				resource.TestCheckResourceAttr(datasourceName, "autonomous_databases.0.local_standby_db.#", "1"),
+				resource.TestCheckResourceAttr(datasourceName, "autonomous_databases.0.ncharacter_set", "AL16UTF16"),
 				resource.TestCheckResourceAttrSet(datasourceName, "autonomous_databases.0.open_mode"),
 				resource.TestCheckResourceAttrSet(datasourceName, "autonomous_databases.0.operations_insights_status"),
 				resource.TestCheckResourceAttrSet(datasourceName, "autonomous_databases.0.database_management_status"),
@@ -845,9 +844,9 @@ func TestDatabaseAutonomousDatabaseResource_basic(t *testing.T) {
 				resource.TestCheckResourceAttr(singularDatasourceName, "local_standby_db.#", "1"),
 				resource.TestCheckResourceAttrSet(singularDatasourceName, "is_preview"),
 				resource.TestCheckResourceAttr(singularDatasourceName, "license_model", "LICENSE_INCLUDED"),
-				// @Codegen:  memory_per_oracle_compute_unit_in_gbs is used only by exacc at the moment
-				//resource.TestCheckResourceAttrSet(singularDatasourceName, "memory_per_oracle_compute_unit_in_gbs"),
 				resource.TestCheckResourceAttr(singularDatasourceName, "max_cpu_core_count", "3"),
+				resource.TestCheckResourceAttr(singularDatasourceName, "local_standby_db.#", "1"),
+				resource.TestCheckResourceAttr(singularDatasourceName, "ncharacter_set", "AL16UTF16"),
 				resource.TestCheckResourceAttrSet(singularDatasourceName, "open_mode"),
 				resource.TestCheckResourceAttrSet(singularDatasourceName, "operations_insights_status"),
 				resource.TestCheckResourceAttrSet(singularDatasourceName, "database_management_status"),

internal/integrationtest/database_autonomous_database_test.go

@@ -78,6 +78,10 @@ func (s *DatabaseAutonomousDatabaseBackupDataSourceCrud) SetData() error {
 		s.D.Set("database_size_in_tbs", *s.Res.DatabaseSizeInTBs)
 	}
 
+	if s.Res.DbVersion != nil {
+		s.D.Set("db_version", *s.Res.DbVersion)
+	}
+
 	if s.Res.DisplayName != nil {
 		s.D.Set("display_name", *s.Res.DisplayName)
 	}
@@ -110,8 +114,20 @@ func (s *DatabaseAutonomousDatabaseBackupDataSourceCrud) SetData() error {
 		s.D.Set("lifecycle_details", *s.Res.LifecycleDetails)
 	}
 
+	if s.Res.RetentionPeriodInDays != nil {
+		s.D.Set("retention_period_in_days", *s.Res.RetentionPeriodInDays)
+	}
+
+	if s.Res.SizeInTBs != nil {
+		s.D.Set("size_in_tbs", *s.Res.SizeInTBs)
+	}
+
 	s.D.Set("state", s.Res.LifecycleState)
 
+	if s.Res.TimeAvailableTill != nil {
+		s.D.Set("time_available_till", s.Res.TimeAvailableTill.String())
+	}
+
 	if s.Res.TimeEnded != nil {
 		s.D.Set("time_ended", s.Res.TimeEnded.String())
 	}

internal/service/database/database_autonomous_database_backup_data_source.go

@@ -25,6 +25,7 @@ func DatabaseAutonomousDatabaseBackupResource() *schema.Resource {
 		Timeouts: tfresource.DefaultTimeout,
 		Create:   createDatabaseAutonomousDatabaseBackup,
 		Read:     readDatabaseAutonomousDatabaseBackup,
+		Update:   updateDatabaseAutonomousDatabaseBackup,
 		Delete:   deleteDatabaseAutonomousDatabaseBackup,
 		Schema: map[string]*schema.Schema{
 			// Required
@@ -35,9 +36,20 @@ func DatabaseAutonomousDatabaseBackupResource() *schema.Resource {
 			},
 			"display_name": {
 				Type:     schema.TypeString,
-				Required: true,
+				Optional: true,
+				Computed: true,
+			},
+			"is_long_term_backup": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				Computed: true,
 				ForceNew: true,
 			},
+			"retention_period_in_days": {
+				Type:     schema.TypeInt,
+				Optional: true,
+				Computed: true,
+			},
 
 			// Optional
 
@@ -50,6 +62,10 @@ func DatabaseAutonomousDatabaseBackupResource() *schema.Resource {
 				Type:     schema.TypeFloat,
 				Computed: true,
 			},
+			"db_version": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 			"is_automatic": {
 				Type:     schema.TypeBool,
 				Computed: true,
@@ -78,10 +94,18 @@ func DatabaseAutonomousDatabaseBackupResource() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			"size_in_tbs": {
+				Type:     schema.TypeFloat,
+				Computed: true,
+			},
 			"state": {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			"time_available_till": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 			"time_ended": {
 				Type:     schema.TypeString,
 				Computed: true,
@@ -120,8 +144,23 @@ func readDatabaseAutonomousDatabaseBackup(d *schema.ResourceData, m interface{})
 	return tfresource.ReadResource(sync)
 }
 
+func updateDatabaseAutonomousDatabaseBackup(d *schema.ResourceData, m interface{}) error {
+	sync := &DatabaseAutonomousDatabaseBackupResourceCrud{}
+	sync.D = d
+	sync.Client = m.(*client.OracleClients).DatabaseClient()
+	sync.WorkRequestClient = m.(*client.OracleClients).WorkRequestClient
+
+	return tfresource.UpdateResource(d, sync)
+}
+
 func deleteDatabaseAutonomousDatabaseBackup(d *schema.ResourceData, m interface{}) error {
-	return nil
+	sync := &DatabaseAutonomousDatabaseBackupResourceCrud{}
+	sync.D = d
+	sync.Client = m.(*client.OracleClients).DatabaseClient()
+	sync.DisableNotFoundRetries = true
+	sync.WorkRequestClient = m.(*client.OracleClients).WorkRequestClient
+
+	return tfresource.DeleteResource(d, sync)
 }
 
 type DatabaseAutonomousDatabaseBackupResourceCrud struct {
@@ -173,6 +212,16 @@ func (s *DatabaseAutonomousDatabaseBackupResourceCrud) Create() error {
 		request.DisplayName = &tmp
 	}
 
+	if isLongTermBackup, ok := s.D.GetOkExists("is_long_term_backup"); ok {
+		tmp := isLongTermBackup.(bool)
+		request.IsLongTermBackup = &tmp
+	}
+
+	if retentionPeriodInDays, ok := s.D.GetOkExists("retention_period_in_days"); ok {
+		tmp := retentionPeriodInDays.(int)
+		request.RetentionPeriodInDays = &tmp
+	}
+
 	request.RequestMetadata.RetryPolicy = tfresource.GetRetryPolicy(s.DisableNotFoundRetries, "database")
 
 	response, err := s.Client.CreateAutonomousDatabaseBackup(context.Background(), request)
@@ -209,6 +258,47 @@ func (s *DatabaseAutonomousDatabaseBackupResourceCrud) Get() error {
 	return nil
 }
 
+func (s *DatabaseAutonomousDatabaseBackupResourceCrud) Update() error {
+	request := oci_database.UpdateAutonomousDatabaseBackupRequest{}
+
+	tmp := s.D.Id()
+	request.AutonomousDatabaseBackupId = &tmp
+
+	if retentionPeriodInDays, ok := s.D.GetOkExists("retention_period_in_days"); ok {
+		tmp := retentionPeriodInDays.(int)
+		request.RetentionPeriodInDays = &tmp
+	}
+
+	request.RequestMetadata.RetryPolicy = tfresource.GetRetryPolicy(s.DisableNotFoundRetries, "database")
+
+	response, err := s.Client.UpdateAutonomousDatabaseBackup(context.Background(), request)
+	if err != nil {
+		return err
+	}
+
+	workId := response.OpcWorkRequestId
+	if workId != nil {
+		_, err = tfresource.WaitForWorkRequestWithErrorHandling(s.WorkRequestClient, workId, "autonomousDatabaseBackup", oci_work_requests.WorkRequestResourceActionTypeUpdated, s.D.Timeout(schema.TimeoutUpdate), s.DisableNotFoundRetries)
+		if err != nil {
+			return err
+		}
+	}
+
+	return s.Get()
+}
+
+func (s *DatabaseAutonomousDatabaseBackupResourceCrud) Delete() error {
+	request := oci_database.DeleteAutonomousDatabaseBackupRequest{}
+
+	tmp := s.D.Id()
+	request.AutonomousDatabaseBackupId = &tmp
+
+	request.RequestMetadata.RetryPolicy = tfresource.GetRetryPolicy(s.DisableNotFoundRetries, "database")
+
+	_, err := s.Client.DeleteAutonomousDatabaseBackup(context.Background(), request)
+	return err
+}
+
 func (s *DatabaseAutonomousDatabaseBackupResourceCrud) SetData() error {
 	if s.Res.AutonomousDatabaseId != nil {
 		s.D.Set("autonomous_database_id", *s.Res.AutonomousDatabaseId)
@@ -222,6 +312,10 @@ func (s *DatabaseAutonomousDatabaseBackupResourceCrud) SetData() error {
 		s.D.Set("database_size_in_tbs", *s.Res.DatabaseSizeInTBs)
 	}
 
+	if s.Res.DbVersion != nil {
+		s.D.Set("db_version", *s.Res.DbVersion)
+	}
+
 	if s.Res.DisplayName != nil {
 		s.D.Set("display_name", *s.Res.DisplayName)
 	}
@@ -254,8 +348,20 @@ func (s *DatabaseAutonomousDatabaseBackupResourceCrud) SetData() error {
 		s.D.Set("lifecycle_details", *s.Res.LifecycleDetails)
 	}
 
+	if s.Res.RetentionPeriodInDays != nil {
+		s.D.Set("retention_period_in_days", *s.Res.RetentionPeriodInDays)
+	}
+
+	if s.Res.SizeInTBs != nil {
+		s.D.Set("size_in_tbs", *s.Res.SizeInTBs)
+	}
+
 	s.D.Set("state", s.Res.LifecycleState)
 
+	if s.Res.TimeAvailableTill != nil {
+		s.D.Set("time_available_till", s.Res.TimeAvailableTill.String())
+	}
+
 	if s.Res.TimeEnded != nil {
 		s.D.Set("time_ended", s.Res.TimeEnded.Format(time.RFC3339Nano))
 	}

internal/service/database/database_autonomous_database_backup_resource.go

@@ -129,6 +129,10 @@ func (s *DatabaseAutonomousDatabaseBackupsDataSourceCrud) SetData() error {
 			autonomousDatabaseBackup["database_size_in_tbs"] = *r.DatabaseSizeInTBs
 		}
 
+		if r.DbVersion != nil {
+			autonomousDatabaseBackup["db_version"] = *r.DbVersion
+		}
+
 		if r.DisplayName != nil {
 			autonomousDatabaseBackup["display_name"] = *r.DisplayName
 		}
@@ -165,8 +169,20 @@ func (s *DatabaseAutonomousDatabaseBackupsDataSourceCrud) SetData() error {
 			autonomousDatabaseBackup["lifecycle_details"] = *r.LifecycleDetails
 		}
 
+		if r.RetentionPeriodInDays != nil {
+			autonomousDatabaseBackup["retention_period_in_days"] = *r.RetentionPeriodInDays
+		}
+
+		if r.SizeInTBs != nil {
+			autonomousDatabaseBackup["size_in_tbs"] = *r.SizeInTBs
+		}
+
 		autonomousDatabaseBackup["state"] = r.LifecycleState
 
+		if r.TimeAvailableTill != nil {
+			autonomousDatabaseBackup["time_available_till"] = r.TimeAvailableTill.String()
+		}
+
 		if r.TimeEnded != nil {
 			autonomousDatabaseBackup["time_ended"] = r.TimeEnded.String()
 		}

internal/service/database/database_autonomous_database_backups_data_source.go

@@ -266,6 +266,16 @@ func (s *DatabaseAutonomousDatabaseDataSourceCrud) SetData() error {
 		s.D.Set("local_standby_db", nil)
 	}
 
+	if s.Res.LongTermBackupSchedule != nil {
+		s.D.Set("long_term_backup_schedule", []interface{}{LongTermBackUpScheduleDetailsToMap(s.Res.LongTermBackupSchedule)})
+	} else {
+		s.D.Set("long_term_backup_schedule", nil)
+	}
+
+	if s.Res.MaxCpuCoreCount != nil {
+		s.D.Set("max_cpu_core_count", *s.Res.MaxCpuCoreCount)
+	}
+
 	if s.Res.MemoryPerOracleComputeUnitInGBs != nil {
 		s.D.Set("memory_per_oracle_compute_unit_in_gbs", *s.Res.MemoryPerOracleComputeUnitInGBs)
 	}
@@ -278,6 +288,10 @@ func (s *DatabaseAutonomousDatabaseDataSourceCrud) SetData() error {
 		s.D.Set("ncharacter_set", *s.Res.NcharacterSet)
 	}
 
+	if s.Res.NextLongTermBackupTimeStamp != nil {
+		s.D.Set("next_long_term_backup_time_stamp", s.Res.NextLongTermBackupTimeStamp.String())
+	}
+
 	s.D.Set("nsg_ids", s.Res.NsgIds)
 
 	if s.Res.OcpuCount != nil {