New Resource: azurerm_site_recovery_hyperv_replicated_vm

internal/services/recoveryservices/azuresdkhacks/replicateditems_client.go

@@ -0,0 +1,18 @@
+package azuresdkhacks
+
+import "github.com/Azure/go-autorest/autorest"
+
+// TODO 4.0: check if this is could be removed
+// workaround for https://github.com/Azure/azure-rest-api-specs/issues/22947
+
+type ReplicationProtectedItemsClient struct {
+	Client  autorest.Client
+	BaseUri string
+}
+
+func NewReplicationProtectedItemsClientWithBaseURI(endpoint string) ReplicationProtectedItemsClient {
+	return ReplicationProtectedItemsClient{
+		Client:  autorest.NewClientWithUserAgent(userAgent()),
+		BaseUri: endpoint,
+	}
+}

internal/services/recoveryservices/azuresdkhacks/replicateditems_method_delete.go

@@ -0,0 +1,77 @@
+package azuresdkhacks
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/hashicorp/go-azure-helpers/polling"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationprotecteditems"
+)
+
+type DeleteOperationResponse struct {
+	Poller       polling.LongRunningPoller
+	HttpResponse *http.Response
+}
+
+// Delete ...
+func (c ReplicationProtectedItemsClient) Delete(ctx context.Context, id replicationprotecteditems.ReplicationProtectedItemId, input DisableProtectionInput) (result DeleteOperationResponse, err error) {
+	req, err := c.preparerForDelete(ctx, id, input)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "replicationprotecteditems.ReplicationProtectedItemsClient", "Delete", nil, "Failure preparing request")
+		return
+	}
+
+	result, err = c.senderForDelete(ctx, req)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "replicationprotecteditems.ReplicationProtectedItemsClient", "Delete", result.HttpResponse, "Failure sending request")
+		return
+	}
+
+	return
+}
+
+// DeleteThenPoll performs Delete then polls until it's completed
+func (c ReplicationProtectedItemsClient) DeleteThenPoll(ctx context.Context, id replicationprotecteditems.ReplicationProtectedItemId, input DisableProtectionInput) error {
+	result, err := c.Delete(ctx, id, input)
+	if err != nil {
+		return fmt.Errorf("performing Delete: %+v", err)
+	}
+
+	if err := result.Poller.PollUntilDone(); err != nil {
+		return fmt.Errorf("polling after Delete: %+v", err)
+	}
+
+	return nil
+}
+
+// preparerForDelete prepares the Delete request.
+func (c ReplicationProtectedItemsClient) preparerForDelete(ctx context.Context, id replicationprotecteditems.ReplicationProtectedItemId, input DisableProtectionInput) (*http.Request, error) {
+	queryParameters := map[string]interface{}{
+		"api-version": defaultApiVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsContentType("application/json; charset=utf-8"),
+		autorest.AsPost(),
+		autorest.WithBaseURL(c.BaseUri),
+		autorest.WithPath(fmt.Sprintf("%s/remove", id.ID())),
+		autorest.WithJSON(input),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// senderForDelete sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (c ReplicationProtectedItemsClient) senderForDelete(ctx context.Context, req *http.Request) (future DeleteOperationResponse, err error) {
+	var resp *http.Response
+	resp, err = c.Client.Send(req, azure.DoRetryWithRegistration(c.Client))
+	if err != nil {
+		return
+	}
+
+	future.Poller, err = polling.NewPollerFromResponse(ctx, resp, c.Client, req.Method)
+	return
+}

internal/services/recoveryservices/azuresdkhacks/replicateditems_model.go

@@ -0,0 +1,8 @@
+package azuresdkhacks
+
+type DisableProtectionInput struct {
+	Properties EmptyInput `json:"properties"`
+}
+
+type EmptyInput struct {
+}

internal/services/recoveryservices/client/client.go

@@ -8,6 +8,7 @@ import (
 	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationfabrics"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationnetworkmappings"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationpolicies"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationprotectableitems"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationprotecteditems"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationprotectioncontainermappings"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationprotectioncontainers"
@@ -38,7 +39,9 @@ type Client struct {
 	ReplicationPoliciesClient                 *replicationpolicies.ReplicationPoliciesClient
 	ContainerMappingClient                    *replicationprotectioncontainermappings.ReplicationProtectionContainerMappingsClient
 	NetworkMappingClient                      *replicationnetworkmappings.ReplicationNetworkMappingsClient
+	ReplicationProtectableItemsClient         *replicationprotectableitems.ReplicationProtectableItemsClient
 	ReplicationProtectedItemsClient           *replicationprotecteditems.ReplicationProtectedItemsClient
+	HackedReplicationProtectedItemsClient     *azuresdkhacks.ReplicationProtectedItemsClient
 	ReplicationRecoveryPlansClient            *replicationrecoveryplans.ReplicationRecoveryPlansClient
 }
 
@@ -97,12 +100,18 @@ func NewClient(o *common.ClientOptions) *Client {
 	networkMappingClient := replicationnetworkmappings.NewReplicationNetworkMappingsClientWithBaseURI(o.ResourceManagerEndpoint)
 	o.ConfigureClient(&networkMappingClient.Client, o.ResourceManagerAuthorizer)
 
+	replicationProtectableItemsCLient := replicationprotectableitems.NewReplicationProtectableItemsClientWithBaseURI(o.ResourceManagerEndpoint)
+	o.ConfigureClient(&replicationProtectableItemsCLient.Client, o.ResourceManagerAuthorizer)
+
 	replicationMigrationItemsClient := replicationprotecteditems.NewReplicationProtectedItemsClientWithBaseURI(o.ResourceManagerEndpoint)
 	o.ConfigureClient(&replicationMigrationItemsClient.Client, o.ResourceManagerAuthorizer)
 
 	replicationRecoveryPlanClient := replicationrecoveryplans.NewReplicationRecoveryPlansClientWithBaseURI(o.ResourceManagerEndpoint)
 	o.ConfigureClient(&replicationRecoveryPlanClient.Client, o.ResourceManagerAuthorizer)
 
+	hackedReplicationProtectedItemsClient := azuresdkhacks.NewReplicationProtectedItemsClientWithBaseURI(o.ResourceManagerEndpoint)
+	o.ConfigureClient(&hackedReplicationProtectedItemsClient.Client, o.ResourceManagerAuthorizer)
+
 	return &Client{
 		ProtectableItemsClient:                    &protectableItemsClient,
 		ProtectedItemsClient:                      &protectedItemsClient,
@@ -122,7 +131,9 @@ func NewClient(o *common.ClientOptions) *Client {
 		ReplicationPoliciesClient:                 &replicationPoliciesClient,
 		ContainerMappingClient:                    &containerMappingClient,
 		NetworkMappingClient:                      &networkMappingClient,
+		ReplicationProtectableItemsClient:         &replicationProtectableItemsCLient,
 		ReplicationProtectedItemsClient:           &replicationMigrationItemsClient,
 		ReplicationRecoveryPlansClient:            &replicationRecoveryPlanClient,
+		HackedReplicationProtectedItemsClient:     &hackedReplicationProtectedItemsClient,
 	}
 }

internal/services/recoveryservices/helpers.go

@@ -1,12 +1,16 @@
 package recoveryservices
 
 import (
+	"context"
+	"fmt"
 	"net/http"
 	"strings"
 
 	"github.com/Azure/go-autorest/autorest"
 	"github.com/Azure/go-autorest/autorest/azure"
 	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationfabrics"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/recoveryservicessiterecovery/2022-10-01/replicationprotectioncontainers"
 )
 
 // This code is a workaround for this bug https://github.com/Azure/azure-sdk-for-go/issues/2824
@@ -36,3 +40,25 @@ func wasBadRequestWithNotExist(resp *http.Response, err error) bool {
 
 	return response.WasBadRequest(resp) && sc == "SubscriptionIdNotRegisteredWithSrs"
 }
+
+func fetchHyperVContainerIdByFabricId(ctx context.Context, containerClient *replicationprotectioncontainers.ReplicationProtectionContainersClient, fabricId replicationfabrics.ReplicationFabricId) (string, error) {
+	id, err := replicationprotectioncontainers.ParseReplicationFabricID(fabricId.ID())
+	if err != nil {
+		return "", fmt.Errorf("parsing %s: %+v", fabricId.ID(), err)
+	}
+
+	resp, err := containerClient.ListByReplicationFabricsComplete(ctx, *id)
+	if err != nil {
+		return "", fmt.Errorf("listing containers: %+v", err)
+	}
+
+	if len(resp.Items) == 0 || len(resp.Items) > 1 {
+		return "", fmt.Errorf("expected one container but got %d", len(resp.Items))
+	}
+
+	if resp.Items[0].Id == nil {
+		return "", fmt.Errorf("container id is nil")
+	}
+
+	return handleAzureSdkForGoBug2824(*resp.Items[0].Id), nil
+}

internal/services/recoveryservices/recovery_services_vault_hyperv_host_test.go

@@ -14,21 +14,24 @@ import (
 	"github.com/hashicorp/terraform-provider-azurerm/utils"
 )
 
-const LetterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+const LowerLetterBytes = "abcdefghijklmnopqrstuvwxyz"
+const UpperLetterBytes = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 const NumberBytes = "1234567890"
 const SpecialBytes = "!@#$%^()"
 
 func GenerateRandomPassword(n int) string {
 	b := make([]byte, n)
 	for i := range b {
 		r := rand.Int()
-		switch r % 3 {
+		switch r % 4 {
 		case 0:
-			b[i] = LetterBytes[rand.Intn(len(LetterBytes))]
+			b[i] = LowerLetterBytes[rand.Intn(len(LowerLetterBytes))]
 		case 1:
 			b[i] = SpecialBytes[rand.Intn(len(SpecialBytes))]
 		case 2:
 			b[i] = NumberBytes[rand.Intn(len(NumberBytes))]
+		case 3:
+			b[i] = UpperLetterBytes[rand.Intn(len(UpperLetterBytes))]
 		}
 	}
 	return string(b)
@@ -100,7 +103,7 @@ func (HyperVHostTestResource) rebootVirtualMachine(ctx context.Context, clients
 func (r HyperVHostTestResource) PrepareHostTestSteps(data acceptance.TestData, adminPwd string) (steps []acceptance.TestStep) {
 	return []acceptance.TestStep{
 		{
-			Config: r.recovery(data),
+			Config: r.recovery(data, true),
 			Check: acceptance.ComposeTestCheckFunc(
 				// set the registration key value to environment variable.
 				data.CheckWithClientForResource(r.generateHyperVHostRegistrationCert(func(xmlContent string) error {
@@ -109,14 +112,14 @@ func (r HyperVHostTestResource) PrepareHostTestSteps(data acceptance.TestData, a
 			),
 		},
 		{
-			Config: r.hyperVTemplate(data, adminPwd), // split complete template into two parts to reboot the server.
+			Config: r.hyperVTemplate(data, adminPwd, true), // split complete template into two parts to reboot the server.
 			Check: acceptance.ComposeTestCheckFunc(
 				data.CheckWithClientForResource(r.virtualMachineExists, "azurerm_windows_virtual_machine.host"),
 				data.CheckWithClientForResource(r.rebootVirtualMachine, "azurerm_windows_virtual_machine.host"),
 			),
 		},
 		{
-			Config: r.template(data, adminPwd),
+			Config: r.template(data, adminPwd, true),
 		},
 	}
 }
@@ -304,7 +307,19 @@ resource "azurerm_network_interface_security_group_association" "hybrid" {
 `
 }
 
-func (r HyperVHostTestResource) recovery(data acceptance.TestData) string {
+// in creating, it should create `hyperv_site` before connect host to it
+// but it needs to remove the `hyperv_site` before deleting the host.
+func (r HyperVHostTestResource) recovery(data acceptance.TestData, includeSite bool) string {
+	siteBlock := ""
+	if includeSite {
+		siteBlock = `
+resource "azurerm_site_recovery_services_vault_hyperv_site" "test" {
+  name              = local.recovery_site_name
+  recovery_vault_id = azurerm_recovery_services_vault.test.id
+}
+`
+	}
+
 	return fmt.Sprintf(`
 %s
 
@@ -317,14 +332,11 @@ resource "azurerm_recovery_services_vault" "test" {
   soft_delete_enabled = false
 }
 
-resource "azurerm_site_recovery_services_vault_hyperv_site" "test" {
-  name              = local.recovery_site_name
-  recovery_vault_id = azurerm_recovery_services_vault.test.id
-}
-`, r.base(data))
+%s
+`, r.base(data), siteBlock)
 }
 
-func (r HyperVHostTestResource) hyperVTemplate(data acceptance.TestData, adminPwd string) string {
+func (r HyperVHostTestResource) hyperVTemplate(data acceptance.TestData, adminPwd string, includeSite bool) string {
 	return fmt.Sprintf(`
 %[1]s
 
@@ -455,10 +467,11 @@ resource "azurerm_windows_virtual_machine" "host" {
 %[3]s
 
 %[4]s
-`, r.recovery(data), adminPwd, r.keyVault(), r.securityGroup())
+`, r.recovery(data, includeSite), adminPwd, r.keyVault(), r.securityGroup())
 }
 
-func (r HyperVHostTestResource) template(data acceptance.TestData, adminPwd string) string {
+// for resources need a connected host, remove site and these resources and then remove the host, or it may fail.
+func (r HyperVHostTestResource) template(data acceptance.TestData, adminPwd string, includeSite bool) string {
 	return fmt.Sprintf(`
 %s
 # register the server could only be done by CustomScriptExtension because it requires local admin to run.
@@ -530,5 +543,5 @@ resource "azurerm_virtual_machine_extension" "script" {
   ]
 }
 
-`, r.hyperVTemplate(data, adminPwd), HostName)
+`, r.hyperVTemplate(data, adminPwd, includeSite), HostName)
 }

internal/services/recoveryservices/registration.go

@@ -29,6 +29,7 @@ func (r Registration) Resources() []sdk.Resource {
 		ReplicationPolicyHyperVResource{},
 		HyperVSiteResource{},
 		HyperVReplicationPolicyAssociationResource{},
+		SiteRecoveryHyperVReplicatedVMResource{},
 	}
 }