azurerm_storage_account - prevent service endpoint error 404 durring re-create

internal/services/storage/storage_account_resource.go

@@ -5,6 +5,7 @@ package storage
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log"
 	"net/http"
@@ -1318,6 +1319,153 @@ func resourceStorageAccountCreate(d *pluginsdk.ResourceData, meta interface{}) e
 
 	supportLevel := resolveStorageAccountServiceSupportLevel(storage.Kind(accountKind), storage.SkuTier(accountTier))
 
+	// Wait for the account services to become available
+
+	if supportLevel.supportBlob {
+		blobClient := meta.(*clients.Client).Storage.BlobServicesClient
+
+		// wait for blob service endpoint to become available
+		log.Printf("[DEBUG] waiting for %s blob service to become available", id.ID())
+		deadline, ok := ctx.Deadline()
+		if !ok {
+			return fmt.Errorf("internal-error: context had no deadline")
+		}
+		stateConf := &pluginsdk.StateChangeConf{
+			Pending: []string{"Pending"},
+			Target:  []string{"Completed"},
+			Refresh: func() (interface{}, string, error) {
+				_, err = blobClient.GetServiceProperties(ctx, id.ResourceGroupName, id.StorageAccountName)
+				if err != nil {
+					return handleStorageServiceError("blob", err)
+				}
+				return true, "Completed", nil
+			},
+			MinTimeout: 10 * time.Second,
+			Timeout:    time.Until(deadline),
+		}
+
+		if _, err = stateConf.WaitForStateContext(ctx); err != nil {
+			return fmt.Errorf("fetching %s blob service properties: %+v", id.ID(), err)
+		}
+	}
+
+	if supportLevel.supportQueue {
+		storageClient := meta.(*clients.Client).Storage
+		account, err := storageClient.FindAccount(ctx, id.StorageAccountName)
+		if err != nil {
+			return fmt.Errorf("retrieving %s: %+v", id, err)
+		}
+		if account == nil {
+			return fmt.Errorf("unable to locate %q", id)
+		}
+
+		queueClient, err := storageClient.QueuesClient(ctx, *account)
+		if err != nil {
+			return fmt.Errorf("building Queues Client: %s", err)
+		}
+
+		// wait for queue service endpoint to become available
+		log.Printf("[DEBUG] waiting for %s queue service to become available", id.ID())
+		deadline, ok := ctx.Deadline()
+		if !ok {
+			return fmt.Errorf("internal-error: context had no deadline")
+		}
+		stateConf := &pluginsdk.StateChangeConf{
+			Pending: []string{"Pending"},
+			Target:  []string{"Completed"},
+			Refresh: func() (interface{}, string, error) {
+				properties, err := queueClient.GetServiceProperties(ctx, id.ResourceGroupName, id.StorageAccountName)
+				if err != nil {
+					return handleStorageServiceError("queue", err)
+				}
+				// workaround for queueClient.GetServiceProperties() not returning 404 error
+				if properties == nil {
+					customErr := azautorest.DetailedError{
+						StatusCode: http.StatusNotFound,
+						Message:    "Failure responding to request",
+					}
+					return handleStorageServiceError("queue", customErr)
+				}
+				return true, "Completed", nil
+			},
+			MinTimeout: 10 * time.Second,
+			Timeout:    time.Until(deadline),
+		}
+
+		if _, err = stateConf.WaitForStateContext(ctx); err != nil {
+			return fmt.Errorf("fetching %s queue service properties: %+v", id.ID(), err)
+		}
+	}
+
+	if supportLevel.supportShare {
+		fileServiceClient := meta.(*clients.Client).Storage.FileServicesClient
+
+		// wait for file service endpoint to become available
+		log.Printf("[DEBUG] waiting for %s file service to become available", id.ID())
+		deadline, ok := ctx.Deadline()
+		if !ok {
+			return fmt.Errorf("internal-error: context had no deadline")
+		}
+		stateConf := &pluginsdk.StateChangeConf{
+			Pending: []string{"Pending"},
+			Target:  []string{"Completed"},
+			Refresh: func() (interface{}, string, error) {
+				_, err = fileServiceClient.GetServiceProperties(ctx, id.ResourceGroupName, id.StorageAccountName)
+				if err != nil {
+					return handleStorageServiceError("file", err)
+				}
+				return true, "Completed", nil
+			},
+			MinTimeout: 10 * time.Second,
+			Timeout:    time.Until(deadline),
+		}
+
+		if _, err = stateConf.WaitForStateContext(ctx); err != nil {
+			return fmt.Errorf("fetching %s file service properties: %+v", id.ID(), err)
+		}
+	}
+
+	if supportLevel.supportStaticWebsite {
+		storageClient := meta.(*clients.Client).Storage
+
+		account, err := storageClient.FindAccount(ctx, id.StorageAccountName)
+		if err != nil {
+			return fmt.Errorf("retrieving %s: %+v", id, err)
+		}
+		if account == nil {
+			return fmt.Errorf("unable to locate %s", id)
+		}
+
+		accountsClient, err := storageClient.AccountsDataPlaneClient(ctx, *account)
+		if err != nil {
+			return fmt.Errorf("building Accounts Data Plane Client: %s", err)
+		}
+
+		// wait for static website endpoint to become available
+		log.Printf("[DEBUG] waiting for %s static website service to become available", id.ID())
+		deadline, ok := ctx.Deadline()
+		if !ok {
+			return fmt.Errorf("internal-error: context had no deadline")
+		}
+		stateConf := &pluginsdk.StateChangeConf{
+			Pending: []string{"Pending"},
+			Target:  []string{"Completed"},
+			Refresh: func() (interface{}, string, error) {
+				_, err = accountsClient.GetServiceProperties(ctx, id.StorageAccountName)
+				if err != nil {
+					return handleStorageServiceError("static website", err)
+				}
+				return true, "Completed", nil
+			},
+			MinTimeout: 10 * time.Second,
+			Timeout:    time.Until(deadline),
+		}
+
+		if _, err = stateConf.WaitForStateContext(ctx); err != nil {
+			return fmt.Errorf("fetching %s static website properties: %+v", id.ID(), err)
+		}
+	}
+
 	if val, ok := d.GetOk("blob_properties"); ok {
 		if !supportLevel.supportBlob {
 			return fmt.Errorf("`blob_properties` aren't supported for account kind %q in sku tier %q", accountKind, accountTier)
@@ -2275,6 +2423,23 @@ func resourceStorageAccountDelete(d *pluginsdk.ResourceData, meta interface{}) e
 	return nil
 }
 
+func handleStorageServiceError(service string, err error) (interface{}, string, error) {
+	// if the error is a DetailedError type, check the status code and return the appropriate state
+	var respErr azautorest.DetailedError
+	if errors.As(err, &respErr) {
+		log.Printf("[DEBUG] error fetching %s service properties: statusCode=%d, message=%s, error=%s\n", service, respErr.StatusCode.(int), respErr.Message, err)
+		// if the status code is 404 (not found), retry the request
+		if respErr.StatusCode.(int) == http.StatusNotFound {
+			// if the status code is 404 (not found), retry the request
+			log.Printf("[DEBUG] %s service is not available, retrying...\n", service)
+			return false, "Pending", nil
+		}
+	}
+	// if the error is unhandled type or status, log the error and return the error state
+	log.Printf("[DEBUG] unexpected error while fetching %s service properties: %v\n", service, err)
+	return nil, "Completed", err
+}
+
 func expandStorageAccountCustomDomain(d *pluginsdk.ResourceData) *storage.CustomDomain {
 	domains := d.Get("custom_domain").([]interface{})
 	if len(domains) == 0 {

internal/services/storage/storage_account_resource_test.go

@@ -67,6 +67,70 @@ func TestAccStorageAccount_requiresImport(t *testing.T) {
 	})
 }
 
+func TestAccStorageAccount_recreateBasic(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_storage_account", "test")
+	r := StorageAccountResource{}
+
+	// fix location to test recreation
+	data.Locations.Primary = "westeurope"
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.basic(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+		{
+			// destroy the account and recreate it
+			Config:  r.recreate(data),
+			Destroy: true,
+		},
+		{
+			Config: r.basic(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
+func TestAccStorageAccount_recreateWithProperties(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_storage_account", "test")
+	r := StorageAccountResource{}
+
+	// fix location to test recreation
+	data.Locations.Primary = "westeurope"
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.recreate(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+		{
+			// destroy the account and recreate it
+			Config:  r.recreate(data),
+			Destroy: true,
+		},
+		{
+			Config: r.recreate(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+				check.That(data.ResourceName).Key("blob_properties.0.versioning_enabled").HasValue("true"),
+				check.That(data.ResourceName).Key("share_properties.0.retention_policy.0.days").HasValue("14"),
+				check.That(data.ResourceName).Key("queue_properties.0.cors_rule.0.max_age_in_seconds").HasValue("3600"),
+				check.That(data.ResourceName).Key("static_website.0.index_document").HasValue("test.html"),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
 func TestAccStorageAccount_noCrossTenantReplication(t *testing.T) {
 	data := acceptance.BuildTestData(t, "azurerm_storage_account", "test")
 	r := StorageAccountResource{}
@@ -1537,6 +1601,56 @@ resource "azurerm_storage_account" "test" {
 `, data.RandomInteger, data.Locations.Primary, data.RandomString)
 }
 
+func (r StorageAccountResource) recreate(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-storage-%d"
+  location = "%s"
+}
+
+resource "azurerm_storage_account" "test" {
+  name                = "unlikely23exst2acct%s"
+  resource_group_name = azurerm_resource_group.test.name
+
+  location                 = azurerm_resource_group.test.location
+  account_tier             = "Standard"
+  account_replication_type = "LRS"
+
+  blob_properties {
+    versioning_enabled = true
+  }
+
+  share_properties {
+    retention_policy {
+      days = 14
+    }
+  }
+
+  queue_properties {
+    cors_rule {
+      allowed_headers    = ["*"]
+      allowed_methods    = ["GET", "POST", "OPTIONS"]
+      allowed_origins    = ["*"]
+      exposed_headers    = ["*"]
+      max_age_in_seconds = 3600
+    }
+  }
+
+  static_website {
+    index_document = "test.html"
+  }
+
+  tags = {
+    environment = "production"
+  }
+}
+`, data.RandomInteger, data.Locations.Primary, data.RandomString)
+}
+
 func (r StorageAccountResource) publicNetworkAccess(data acceptance.TestData, enabled bool) string {
 	return fmt.Sprintf(`
 provider "azurerm" {