new resrouce azurerm_data_protection_backup_instance_data_lake_storage

Author: teowa

internal/services/dataprotection/custompollers/data_protection_backup_instance_poller.go

@@ -0,0 +1,58 @@
+// Copyright IBM Corp. 2014, 2025
+// SPDX-License-Identifier: MPL-2.0
+
+package custompollers
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/dataprotection/2025-09-01/backupinstanceresources"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+)
+
+var _ pollers.PollerType = &dataProtectionBackupInstancePoller{}
+
+type dataProtectionBackupInstancePoller struct {
+	client *backupinstanceresources.BackupInstanceResourcesClient
+	id     backupinstanceresources.BackupInstanceId
+}
+
+var (
+	backupInstancePollingSuccess = pollers.PollResult{
+		PollInterval: 30 * time.Second,
+		Status:       pollers.PollingStatusSucceeded,
+	}
+	backupInstancePollingInProgress = pollers.PollResult{
+		HttpResponse: nil,
+		PollInterval: 30 * time.Second,
+		Status:       pollers.PollingStatusInProgress,
+	}
+)
+
+func NewDataProtectionBackupInstancePoller(client *backupinstanceresources.BackupInstanceResourcesClient, id backupinstanceresources.BackupInstanceId) *dataProtectionBackupInstancePoller {
+	return &dataProtectionBackupInstancePoller{
+		client: client,
+		id:     id,
+	}
+}
+
+func (p dataProtectionBackupInstancePoller) Poll(ctx context.Context) (*pollers.PollResult, error) {
+	resp, err := p.client.BackupInstancesGet(ctx, p.id)
+	if err != nil {
+		return nil, fmt.Errorf("retrieving %s: %+v", p.id, err)
+	}
+
+	if resp.Model == nil || resp.Model.Properties == nil {
+		return nil, fmt.Errorf("polling for %s: `model` or `properties` was nil", p.id)
+	}
+
+	protectionState := pointer.From(resp.Model.Properties.CurrentProtectionState)
+	if protectionState == backupinstanceresources.CurrentProtectionStateProtectionConfigured {
+		return &backupInstancePollingSuccess, nil
+	}
+
+	return &backupInstancePollingInProgress, nil
+}

internal/services/dataprotection/data_protection_backup_instance_data_lake_storage_resource.go

@@ -0,0 +1,302 @@
+// Copyright IBM Corp. 2014, 2025
+// SPDX-License-Identifier: MPL-2.0
+
+package dataprotection
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/location"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/dataprotection/2025-09-01/backupinstanceresources"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/dataprotection/2025-09-01/backupvaultresources"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/dataprotection/2025-09-01/basebackuppolicyresources"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/sdk"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/services/dataprotection/custompollers"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
+)
+
+//go:generate go run ../../tools/generator-tests resourceidentity -resource-name data_protection_backup_instance_data_lake_storage -service-package-name dataprotection -properties "name" -compare-values "subscription_id:vault_id,resource_group_name:vault_id,backup_vault_name:vault_id"
+
+type BackupInstanceDataLakeStorageModel struct {
+	Name             string `tfschema:"name"`
+	Location         string `tfschema:"location"`
+	VaultId          string `tfschema:"vault_id"`
+	BackupPolicyId   string `tfschema:"backup_policy_id"`
+	StorageAccountId string `tfschema:"storage_account_id"`
+	ProtectionState  string `tfschema:"protection_state"`
+}
+
+type DataProtectionBackupInstanceDataLakeStorageResource struct{}
+
+var (
+	_ sdk.Resource             = DataProtectionBackupInstanceDataLakeStorageResource{}
+	_ sdk.ResourceWithIdentity = DataProtectionBackupInstanceDataLakeStorageResource{}
+)
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) Identity() resourceids.ResourceId {
+	return &backupinstanceresources.BackupInstanceId{}
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) ResourceType() string {
+	return "azurerm_data_protection_backup_instance_data_lake_storage"
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) ModelObject() interface{} {
+	return &BackupInstanceDataLakeStorageModel{}
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) IDValidationFunc() pluginsdk.SchemaValidateFunc {
+	return backupinstanceresources.ValidateBackupInstanceID
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) Arguments() map[string]*pluginsdk.Schema {
+	return map[string]*pluginsdk.Schema{
+		"name": {
+			Type:         pluginsdk.TypeString,
+			Required:     true,
+			ForceNew:     true,
+			ValidateFunc: validation.StringIsNotEmpty,
+		},
+
+		"location": commonschema.Location(),
+
+		"vault_id": commonschema.ResourceIDReferenceRequiredForceNew(&basebackuppolicyresources.BackupVaultId{}),
+
+		"backup_policy_id": commonschema.ResourceIDReferenceRequired(&basebackuppolicyresources.BackupPolicyId{}),
+
+		"storage_account_id": commonschema.ResourceIDReferenceRequiredForceNew(&commonids.StorageAccountId{}),
+	}
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) Attributes() map[string]*pluginsdk.Schema {
+	return map[string]*pluginsdk.Schema{
+		"protection_state": {
+			Type:     pluginsdk.TypeString,
+			Computed: true,
+		},
+	}
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) Create() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 60 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			var model BackupInstanceDataLakeStorageModel
+			if err := metadata.Decode(&model); err != nil {
+				return fmt.Errorf("decoding: %+v", err)
+			}
+
+			client := metadata.Client.DataProtection.BackupInstanceClient
+
+			vaultId, err := backupvaultresources.ParseBackupVaultID(model.VaultId)
+			if err != nil {
+				return err
+			}
+
+			id := backupinstanceresources.NewBackupInstanceID(vaultId.SubscriptionId, vaultId.ResourceGroupName, vaultId.BackupVaultName, model.Name)
+
+			existing, err := client.BackupInstancesGet(ctx, id)
+			if err != nil {
+				if !response.WasNotFound(existing.HttpResponse) {
+					return fmt.Errorf("checking for existing %s: %+v", id, err)
+				}
+			}
+
+			if !response.WasNotFound(existing.HttpResponse) {
+				return metadata.ResourceRequiresImport(r.ResourceType(), id)
+			}
+
+			storageAccountId, err := commonids.ParseStorageAccountID(model.StorageAccountId)
+			if err != nil {
+				return err
+			}
+
+			policyId, err := basebackuppolicyresources.ParseBackupPolicyID(model.BackupPolicyId)
+			if err != nil {
+				return err
+			}
+
+			parameters := backupinstanceresources.BackupInstanceResource{
+				Properties: &backupinstanceresources.BackupInstance{
+					DataSourceInfo: backupinstanceresources.Datasource{
+						DatasourceType:   pointer.To("Microsoft.Storage/storageAccounts/adlsBlobServices"),
+						ObjectType:       pointer.To("Datasource"),
+						ResourceID:       storageAccountId.ID(),
+						ResourceLocation: pointer.To(location.Normalize(model.Location)),
+						ResourceName:     pointer.To(storageAccountId.StorageAccountName),
+						ResourceType:     pointer.To("Microsoft.Storage/storageAccounts"),
+						ResourceUri:      pointer.To(storageAccountId.ID()),
+					},
+					DataSourceSetInfo: &backupinstanceresources.DatasourceSet{
+						DatasourceType:   pointer.To("Microsoft.Storage/storageAccounts/adlsBlobServices"),
+						ObjectType:       pointer.To("DatasourceSet"),
+						ResourceID:       storageAccountId.ID(),
+						ResourceLocation: pointer.To(location.Normalize(model.Location)),
+						ResourceName:     pointer.To(storageAccountId.StorageAccountName),
+						ResourceType:     pointer.To("Microsoft.Storage/storageAccounts"),
+						ResourceUri:      pointer.To(storageAccountId.ID()),
+					},
+					FriendlyName: pointer.To(id.BackupInstanceName),
+					PolicyInfo: backupinstanceresources.PolicyInfo{
+						PolicyId: policyId.ID(),
+					},
+				},
+			}
+
+			if err := client.BackupInstancesCreateOrUpdateThenPoll(ctx, id, parameters, backupinstanceresources.DefaultBackupInstancesCreateOrUpdateOperationOptions()); err != nil {
+				return fmt.Errorf("creating %s: %+v", id, err)
+			}
+
+			pollerType := custompollers.NewDataProtectionBackupInstancePoller(client, id)
+			poller := pollers.NewPoller(pollerType, 30*time.Second, pollers.DefaultNumberOfDroppedConnectionsToAllow)
+			if err := poller.PollUntilDone(ctx); err != nil {
+				return err
+			}
+
+			metadata.SetID(id)
+			if err := pluginsdk.SetResourceIdentityData(metadata.ResourceData, &id); err != nil {
+				return err
+			}
+			return nil
+		},
+	}
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) Read() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 5 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			client := metadata.Client.DataProtection.BackupInstanceClient
+
+			id, err := backupinstanceresources.ParseBackupInstanceID(metadata.ResourceData.Id())
+			if err != nil {
+				return err
+			}
+
+			resp, err := client.BackupInstancesGet(ctx, *id)
+			if err != nil {
+				if response.WasNotFound(resp.HttpResponse) {
+					return metadata.MarkAsGone(*id)
+				}
+
+				return fmt.Errorf("retrieving %s: %+v", *id, err)
+			}
+
+			vaultId := backupvaultresources.NewBackupVaultID(id.SubscriptionId, id.ResourceGroupName, id.BackupVaultName)
+
+			state := BackupInstanceDataLakeStorageModel{
+				Name:    id.BackupInstanceName,
+				VaultId: vaultId.ID(),
+			}
+
+			if model := resp.Model; model != nil {
+				if props := model.Properties; props != nil {
+					state.Location = location.NormalizeNilable(props.DataSourceInfo.ResourceLocation)
+
+					storageAccountId, err := commonids.ParseStorageAccountIDInsensitively(props.DataSourceInfo.ResourceID)
+					if err != nil {
+						return err
+					}
+					state.StorageAccountId = storageAccountId.ID()
+
+					backupPolicyId, err := basebackuppolicyresources.ParseBackupPolicyIDInsensitively(props.PolicyInfo.PolicyId)
+					if err != nil {
+						return err
+					}
+					state.BackupPolicyId = backupPolicyId.ID()
+
+					state.ProtectionState = pointer.FromEnum(props.CurrentProtectionState)
+				}
+			}
+
+			if err := pluginsdk.SetResourceIdentityData(metadata.ResourceData, id); err != nil {
+				return err
+			}
+			return metadata.Encode(&state)
+		},
+	}
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) Update() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 60 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			client := metadata.Client.DataProtection.BackupInstanceClient
+
+			id, err := backupinstanceresources.ParseBackupInstanceID(metadata.ResourceData.Id())
+			if err != nil {
+				return err
+			}
+
+			var model BackupInstanceDataLakeStorageModel
+			if err := metadata.Decode(&model); err != nil {
+				return fmt.Errorf("decoding: %+v", err)
+			}
+
+			existing, err := client.BackupInstancesGet(ctx, *id)
+			if err != nil {
+				if response.WasNotFound(existing.HttpResponse) {
+					return metadata.MarkAsGone(id)
+				}
+
+				return fmt.Errorf("reading %s: %+v", *id, err)
+			}
+
+			if existing.Model == nil {
+				return fmt.Errorf("retrieving %s: `model` was nil", id)
+			}
+
+			parameters := *existing.Model
+
+			if metadata.ResourceData.HasChange("backup_policy_id") {
+				policyId, err := basebackuppolicyresources.ParseBackupPolicyID(model.BackupPolicyId)
+				if err != nil {
+					return err
+				}
+				parameters.Properties.PolicyInfo.PolicyId = policyId.ID()
+			}
+
+			if err := client.BackupInstancesCreateOrUpdateThenPoll(ctx, *id, parameters, backupinstanceresources.DefaultBackupInstancesCreateOrUpdateOperationOptions()); err != nil {
+				return fmt.Errorf("updating %s: %+v", id, err)
+			}
+
+			pollerType := custompollers.NewDataProtectionBackupInstancePoller(client, *id)
+			poller := pollers.NewPoller(pollerType, 30*time.Second, pollers.DefaultNumberOfDroppedConnectionsToAllow)
+			if err := poller.PollUntilDone(ctx); err != nil {
+				return err
+			}
+
+			return nil
+		},
+	}
+}
+
+func (r DataProtectionBackupInstanceDataLakeStorageResource) Delete() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 60 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			client := metadata.Client.DataProtection.BackupInstanceClient
+
+			id, err := backupinstanceresources.ParseBackupInstanceID(metadata.ResourceData.Id())
+			if err != nil {
+				return err
+			}
+
+			err = client.BackupInstancesDeleteThenPoll(ctx, *id, backupinstanceresources.DefaultBackupInstancesDeleteOperationOptions())
+			if err != nil {
+				return fmt.Errorf("deleting %s: %+v", *id, err)
+			}
+
+			return nil
+		},
+	}
+}