Merge pull request #6786 from r0bnet/analysis-services-server-update-…

…when-paused

[Enhancement] Allow updating Analysis Services Server when paused

azurerm/internal/services/analysisservices/analysis_services_server_resource.go

@@ -249,13 +249,35 @@ func resourceArmAnalysisServicesServerUpdate(d *schema.ResourceData, meta interf
 	ctx, cancel := timeouts.ForUpdate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	log.Printf("[INFO] preparing arguments for Azure ARM Analysis Services Server creation.")
+	log.Printf("[INFO] preparing arguments for Azure ARM Analysis Services Server update.")
 
 	id, err := parse.AnalysisServicesServerID(d.Id())
 	if err != nil {
 		return err
 	}
 
+	serverResp, err := client.GetDetails(ctx, id.ResourceGroup, id.Name)
+	if err != nil {
+		return fmt.Errorf("Error retrieving Analysis Services Server %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
+	}
+
+	if serverResp.State != analysisservices.StateSucceeded && serverResp.State != analysisservices.StatePaused {
+		return fmt.Errorf("Error updating Analysis Services Server %q (Resource Group %q): State must be either Succeeded or Paused but got %q", id.Name, id.ResourceGroup, serverResp.State)
+	}
+
+	isPaused := serverResp.State == analysisservices.StatePaused
+
+	if isPaused {
+		resumeFuture, err := client.Resume(ctx, id.ResourceGroup, id.Name)
+		if err != nil {
+			return fmt.Errorf("Error starting Analysis Services Server %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
+		}
+
+		if err = resumeFuture.WaitForCompletionRef(ctx, client.Client); err != nil {
+			return fmt.Errorf("Error waiting for Analysis Services Server starting completion %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
+		}
+	}
+
 	serverProperties := expandAnalysisServicesServerMutableProperties(d)
 	sku := d.Get("sku").(string)
 	t := d.Get("tags").(map[string]interface{})
@@ -275,6 +297,17 @@ func resourceArmAnalysisServicesServerUpdate(d *schema.ResourceData, meta interf
 		return fmt.Errorf("Error waiting for completion of Analysis Services Server %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
 	}
 
+	if isPaused {
+		suspendFuture, err := client.Suspend(ctx, id.ResourceGroup, id.Name)
+		if err != nil {
+			return fmt.Errorf("Error re-pausing Analysis Services Server %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
+		}
+
+		if err = suspendFuture.WaitForCompletionRef(ctx, client.Client); err != nil {
+			return fmt.Errorf("Error waiting for Analysis Services Server pausing completion %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
+		}
+	}
+
 	return resourceArmAnalysisServicesServerRead(d, meta)
 }
 

azurerm/internal/services/analysisservices/tests/analysis_services_server_resource_test.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/Azure/azure-sdk-for-go/services/analysisservices/mgmt/2017-08-01/analysisservices"
 	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
 	"github.com/hashicorp/terraform-plugin-sdk/terraform"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance"
@@ -210,6 +211,33 @@ func TestAccAzureRMAnalysisServicesServer_backupBlobContainerUri(t *testing.T) {
 	})
 }
 
+func TestAccAzureRMAnalysisServicesServer_suspended(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_analysis_services_server", "test")
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { acceptance.PreCheck(t) },
+		Providers:    acceptance.SupportedProviders,
+		CheckDestroy: testCheckAzureRMAnalysisServicesServerDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAzureRMAnalysisServicesServer_basic(data),
+				Check: resource.ComposeTestCheckFunc(
+					testCheckAzureRMAnalysisServicesServerExists(data.ResourceName),
+					testSuspendAzureRMAnalysisServicesServer(data.ResourceName),
+					testCheckAzureRMAnalysisServicesServerState(data.ResourceName, analysisservices.StatePaused),
+				),
+			},
+			{
+				Config: testAccAzureRMAnalysisServicesServer_scale(data),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(data.ResourceName, "sku", "S1"),
+					testCheckAzureRMAnalysisServicesServerState(data.ResourceName, analysisservices.StatePaused),
+				),
+			},
+		},
+	})
+}
+
 func testAccAzureRMAnalysisServicesServer_basic(data acceptance.TestData) string {
 	return fmt.Sprintf(`
 provider "azurerm" {
@@ -477,6 +505,26 @@ resource "azurerm_analysis_services_server" "test" {
 `, data.RandomInteger, data.Locations.Primary, data.RandomString, data.RandomInteger)
 }
 
+func testAccAzureRMAnalysisServicesServer_scale(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-%d"
+  location = "%s"
+}
+
+resource "azurerm_analysis_services_server" "test" {
+  name                = "acctestass%d"
+  location            = azurerm_resource_group.test.location
+  resource_group_name = azurerm_resource_group.test.name
+  sku                 = "S1"
+}
+`, data.RandomInteger, data.Locations.Primary, data.RandomInteger)
+}
+
 func testCheckAzureRMAnalysisServicesServerDestroy(s *terraform.State) error {
 	client := acceptance.AzureProvider.Meta().(*clients.Client).AnalysisServices.ServerClient
 	ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext
@@ -533,3 +581,60 @@ func testCheckAzureRMAnalysisServicesServerExists(resourceName string) resource.
 		return nil
 	}
 }
+
+func testSuspendAzureRMAnalysisServicesServer(resourceName string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		client := acceptance.AzureProvider.Meta().(*clients.Client).AnalysisServices.ServerClient
+		ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext
+
+		rs, ok := s.RootModule().Resources[resourceName]
+		if !ok {
+			return fmt.Errorf("Not found: %s", resourceName)
+		}
+
+		id, err := parse.AnalysisServicesServerID(rs.Primary.ID)
+		if err != nil {
+			return err
+		}
+
+		suspendFuture, err := client.Suspend(ctx, id.ResourceGroup, id.Name)
+		if err != nil {
+			return fmt.Errorf("Bad: Suspend on analysisServicesServerClient: %+v", err)
+		}
+
+		err = suspendFuture.WaitForCompletionRef(ctx, client.Client)
+		if err != nil {
+			return fmt.Errorf("Bad: Wait for Suspend completion on analysisServicesServerClient: %+v", err)
+		}
+
+		return nil
+	}
+}
+
+func testCheckAzureRMAnalysisServicesServerState(resourceName string, state analysisservices.State) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		client := acceptance.AzureProvider.Meta().(*clients.Client).AnalysisServices.ServerClient
+		ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext
+
+		rs, ok := s.RootModule().Resources[resourceName]
+		if !ok {
+			return fmt.Errorf("Not found: %s", resourceName)
+		}
+
+		id, err := parse.AnalysisServicesServerID(rs.Primary.ID)
+		if err != nil {
+			return err
+		}
+
+		resp, err := client.GetDetails(ctx, id.ResourceGroup, id.Name)
+		if err != nil {
+			return fmt.Errorf("Bad: Get on analysisServicesServerClient: %+v", err)
+		}
+
+		if resp.State != state {
+			return fmt.Errorf("Unexpected state. Expected %s but is %s", state, resp.State)
+		}
+
+		return nil
+	}
+}

website/docs/r/analysis_services_server.html.markdown

@@ -38,6 +38,8 @@ resource "azurerm_analysis_services_server" "server" {
 }
 ```
 
+-> **NOTE:** The server resource will automatically be started and stopped during an update if it is in `paused` state.
+
 ## Argument Reference
 
 The following arguments are supported:
@@ -52,7 +54,7 @@ The following arguments are supported:
 
 * `admin_users` - (Optional) List of email addresses of admin users.
 
-* `querypool_connection_mode` - (Optional) Controls how the read-write server is used in the query pool. If this values is set to `All` then read-write servers are also used for queries. Otherwise with `ReadOnly` these servers do not participate in query operations.
+* `querypool_connection_mode` - (Optional) Controls how the read-write server is used in the query pool. If this value is set to `All` then read-write servers are also used for queries. Otherwise with `ReadOnly` these servers do not participate in query operations.
 
 * `backup_blob_container_uri` - (Optional) URI and SAS token for a blob container to store backups.