feat(rdb): add 8 new RDB actions with tests and documentation

Author: jremy42

internal/locality/regional/schemas_framework.go

@@ -0,0 +1,24 @@
+package regional
+
+import (
+	"github.com/hashicorp/terraform-plugin-framework/action/schema"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+// AllRegions returns all valid Scaleway regions as strings
+func AllRegions() []string {
+	regions := make([]string, 0, len(scw.AllRegions))
+	for _, r := range scw.AllRegions {
+		regions = append(regions, r.String())
+	}
+
+	return regions
+}
+
+// SchemaAttribute returns a Plugin Framework schema attribute for a region field
+func SchemaAttribute() schema.StringAttribute {
+	return schema.StringAttribute{
+		Optional:    true,
+		Description: "The region you want to attach the resource to",
+	}
+}

internal/services/rdb/action_database_backup_export_action.go

@@ -0,0 +1,175 @@
+package rdb
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/action"
+	"github.com/hashicorp/terraform-plugin-framework/action/schema"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	rdb "github.com/scaleway/scaleway-sdk-go/api/rdb/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/regional"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/meta"
+)
+
+var (
+	_ action.Action              = (*DatabaseBackupExportAction)(nil)
+	_ action.ActionWithConfigure = (*DatabaseBackupExportAction)(nil)
+)
+
+// DatabaseBackupExportAction exports a database backup.
+type DatabaseBackupExportAction struct {
+	rdbAPI *rdb.API
+	meta   *meta.Meta
+}
+
+func (a *DatabaseBackupExportAction) Configure(_ context.Context, req action.ConfigureRequest, resp *action.ConfigureResponse) {
+	if req.ProviderData == nil {
+		return
+	}
+
+	m, ok := req.ProviderData.(*meta.Meta)
+	if !ok {
+		resp.Diagnostics.AddError(
+			"Unexpected Action Configure Type",
+			fmt.Sprintf("Expected *meta.Meta, got: %T. Please report this issue to the provider developers.", req.ProviderData),
+		)
+
+		return
+	}
+
+	a.meta = m
+	a.rdbAPI = newAPI(m)
+}
+
+func (a *DatabaseBackupExportAction) Metadata(_ context.Context, req action.MetadataRequest, resp *action.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_rdb_database_backup_export_action"
+}
+
+type DatabaseBackupExportActionModel struct {
+	BackupID types.String `tfsdk:"backup_id"`
+	Region   types.String `tfsdk:"region"`
+	Wait     types.Bool   `tfsdk:"wait"`
+}
+
+// NewDatabaseBackupExportAction returns a new RDB database backup export action.
+func NewDatabaseBackupExportAction() action.Action {
+	return &DatabaseBackupExportAction{}
+}
+
+func (a *DatabaseBackupExportAction) Schema(_ context.Context, _ action.SchemaRequest, resp *action.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"backup_id": schema.StringAttribute{
+				Required:    true,
+				Description: "Database backup ID to export. Can be a plain UUID or a regional ID."},
+			"region": regional.SchemaAttribute(),
+			"wait": schema.BoolAttribute{
+				Optional:    true,
+				Description: "Wait for the export operation to complete before returning.",
+			},
+		},
+	}
+}
+
+func (a *DatabaseBackupExportAction) Invoke(ctx context.Context, req action.InvokeRequest, resp *action.InvokeResponse) {
+	var data DatabaseBackupExportActionModel
+
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
+
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	if a.rdbAPI == nil {
+		resp.Diagnostics.AddError(
+			"Unconfigured rdbAPI",
+			"The action was not properly configured. The Scaleway client is missing. "+
+				"This is usually a bug in the provider. Please report it to the maintainers.",
+		)
+
+		return
+	}
+
+	if data.BackupID.IsNull() || data.BackupID.IsUnknown() || data.BackupID.ValueString() == "" {
+		resp.Diagnostics.AddError(
+			"Missing backup_id",
+			"The backup_id attribute is required to export a database backup.",
+		)
+
+		return
+	}
+
+	backupID := locality.ExpandID(data.BackupID.ValueString())
+
+	var region scw.Region
+
+	if !data.Region.IsNull() && !data.Region.IsUnknown() && data.Region.ValueString() != "" {
+		parsedRegion, err := scw.ParseRegion(data.Region.ValueString())
+		if err != nil {
+			resp.Diagnostics.AddError(
+				"Invalid region value",
+				fmt.Sprintf("The region attribute must be a valid Scaleway region. Got %q: %s", data.Region.ValueString(), err),
+			)
+
+			return
+		}
+
+		region = parsedRegion
+	} else {
+		if derivedRegion, id, parseErr := regional.ParseID(data.BackupID.ValueString()); parseErr == nil {
+			region = derivedRegion
+			backupID = id
+		} else if a.meta != nil {
+			defaultRegion, exists := a.meta.ScwClient().GetDefaultRegion()
+			if !exists {
+				resp.Diagnostics.AddError(
+					"Unable to determine region",
+					"Failed to get default region from provider configuration. Please set the region attribute, use a regional backup_id, or configure a default region in the provider.",
+				)
+
+				return
+			}
+
+			region = defaultRegion
+		}
+	}
+
+	if region == "" {
+		resp.Diagnostics.AddError(
+			"Missing region",
+			"Could not determine region for RDB database backup export. Please set the region attribute, use a regional backup_id, or configure a default region in the provider.",
+		)
+
+		return
+	}
+
+	exportReq := &rdb.ExportDatabaseBackupRequest{
+		Region:           region,
+		DatabaseBackupID: backupID,
+	}
+
+	_, err := a.rdbAPI.ExportDatabaseBackup(exportReq, scw.WithContext(ctx))
+	if err != nil {
+		resp.Diagnostics.AddError(
+			"Error executing RDB ExportDatabaseBackup action",
+			fmt.Sprintf("Failed to export backup %s: %s", backupID, err),
+		)
+
+		return
+	}
+
+	if data.Wait.ValueBool() {
+		_, err = waitForRDBDatabaseBackup(ctx, a.rdbAPI, region, backupID, defaultInstanceTimeout)
+		if err != nil {
+			resp.Diagnostics.AddError(
+				"Error waiting for RDB database backup export completion",
+				fmt.Sprintf("Export operation for backup %s did not complete: %s", backupID, err),
+			)
+
+			return
+		}
+	}
+}

internal/services/rdb/action_database_backup_export_action_test.go

@@ -0,0 +1,107 @@
+package rdb_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/terraform"
+	rdbSDK "github.com/scaleway/scaleway-sdk-go/api/rdb/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/acctest"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/regional"
+)
+
+func TestAccActionRDBDatabaseBackupExport_Basic(t *testing.T) {
+	if acctest.IsRunningOpenTofu() {
+		t.Skip("Skipping TestAccActionRDBDatabaseBackupExport_Basic because action are not yet supported on OpenTofu")
+	}
+
+	tt := acctest.NewTestTools(t)
+	defer tt.Cleanup()
+
+	resource.ParallelTest(t, resource.TestCase{
+		ProtoV6ProviderFactories: tt.ProviderFactories,
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_rdb_instance" "main" {
+						name = "test-rdb-action-backup-export"
+						node_type = "db-dev-s"
+						engine = "PostgreSQL-15"
+						is_ha_cluster = false
+						disable_backup = true
+						user_name = "my_initial_user"
+						password = "thiZ_is_v&ry_s3cret"
+						volume_type = "sbs_5k"
+						volume_size_in_gb = 10
+					}
+
+					resource "scaleway_rdb_database" "main" {
+						instance_id = scaleway_rdb_instance.main.id
+						name = "test_db"
+					}
+
+					resource "scaleway_rdb_database_backup" "main" {
+						instance_id = scaleway_rdb_instance.main.id
+						database_name = scaleway_rdb_database.main.name
+						name = "test-backup-export"
+						depends_on = [scaleway_rdb_database.main]
+
+						lifecycle {
+							action_trigger {
+								events  = [after_create]
+								actions = [action.scaleway_rdb_database_backup_export_action.main]
+							}
+						}
+					}
+
+					action "scaleway_rdb_database_backup_export_action" "main" {
+						config {
+							backup_id = scaleway_rdb_database_backup.main.id
+							wait = true
+						}
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					isBackupExported(tt, "scaleway_rdb_database_backup.main"),
+				),
+			},
+		},
+	})
+}
+
+func isBackupExported(tt *acctest.TestTools, resourceName string) resource.TestCheckFunc {
+	return func(state *terraform.State) error {
+		rs, ok := state.RootModule().Resources[resourceName]
+		if !ok {
+			return fmt.Errorf("not found: %s", resourceName)
+		}
+
+		region, id, err := regional.ParseID(rs.Primary.ID)
+		if err != nil {
+			return fmt.Errorf("failed to parse backup ID: %w", err)
+		}
+
+		api := rdbSDK.NewAPI(tt.Meta.ScwClient())
+
+		backup, err := api.GetDatabaseBackup(&rdbSDK.GetDatabaseBackupRequest{
+			Region:           region,
+			DatabaseBackupID: id,
+		}, scw.WithContext(context.Background()))
+		if err != nil {
+			return fmt.Errorf("failed to get backup: %w", err)
+		}
+
+		if backup == nil {
+			return fmt.Errorf("backup %s not found", id)
+		}
+
+		if backup.Status != rdbSDK.DatabaseBackupStatusReady {
+			return fmt.Errorf("backup %s is not ready, status: %s", id, backup.Status)
+		}
+
+		return nil
+	}
+}