feat: Adds skip_wait_on_update to mongodbatlas_search_deployment to support returning early after an update (#3237)

* init

* refactor: Rename schema to skip_wait_on_update

* lint fixes

* doc: Updates description of skip_wait_on_update

* chore: Add changelog entry for skip_wait_on_update enhancement

* revert: `extraTargetStates ...string` approach

* refactor: use the skipWaitOnUpdate directly to avoid the WaitSearchNodeStateTransition

* test: Check skip_wait_on_update

* Update resource_search_deployment.go

* update changelog

* doc: Adds import note

* refactor: use OverridenFields

* test: Use ProjectIDExecutionWithCluster

* doc: Update attribute description

* refactor: revert back migration test to use `MONGODB_ATLAS_PROJECT_EAR_PE_AWS_ID`

---------

Co-authored-by: rpabasara <[email protected]>
Co-authored-by: ridmagroupby <[email protected]>

Author: 3 people

.changelog/3237.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+resource/mongodbatlas_search_deployment: Adds `skip_wait_on_update` to avoid waiting for completion of update operations
+```

docs/resources/search_deployment.md

@@ -68,6 +68,7 @@ output "mongodbatlas_search_deployment_encryption_at_rest_provider" {
 
 ### Optional
 
+- `skip_wait_on_update` (Boolean) If true, the resource update is executed without waiting until the [state](#state_name-1) is `IDLE`, making the operation faster. This might cause update errors to go unnoticed and lead to non-empty plans at the next terraform execution.
 - `timeouts` (Attributes) (see [below for nested schema](#nestedatt--timeouts))
 
 ### Read-Only
@@ -101,4 +102,6 @@ Search node resource can be imported using the project ID and cluster name, in t
 $ terraform import mongodbatlas_search_deployment.test 650972848269185c55f40ca1-Cluster0
 ```
 
+After an import, a non-empty plan is expected if the configuration defines the `skip_wait_on_update` attribute. However, the update will not have any effect on the search deployment since `skip_wait_on_update` only relates to the update operations wait time.
+
 For more information see: [MongoDB Atlas API - Search Node](https://www.mongodb.com/docs/atlas/reference/api-resources-spec/#tag/Atlas-Search/operation/createAtlasSearchDeployment) Documentation.

internal/service/searchdeployment/data_source.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/config"
 )
@@ -27,6 +28,9 @@ type searchDeploymentDS struct {
 func (d *searchDeploymentDS) Schema(ctx context.Context, req datasource.SchemaRequest, resp *datasource.SchemaResponse) {
 	resp.Schema = conversion.DataSourceSchemaFromResource(ResourceSchema(ctx), &conversion.DataSourceSchemaRequest{
 		RequiredFields: []string{"project_id", "cluster_name"},
+		OverridenFields: map[string]schema.Attribute{
+			"skip_wait_on_update": nil,
+		},
 	})
 }
 

internal/service/searchdeployment/resource.go

@@ -82,6 +82,7 @@ func (r *searchDeploymentRS) Create(ctx context.Context, req resource.CreateRequ
 	if resp.Diagnostics.HasError() {
 		return
 	}
+	newSearchNodeModel.SkipWaitOnUpdate = searchDeploymentPlan.SkipWaitOnUpdate
 	resp.Diagnostics.Append(resp.State.Set(ctx, newSearchNodeModel)...)
 }
 
@@ -115,6 +116,7 @@ func (r *searchDeploymentRS) Read(ctx context.Context, req resource.ReadRequest,
 	if resp.Diagnostics.HasError() {
 		return
 	}
+	newSearchNodeModel.SkipWaitOnUpdate = searchDeploymentPlan.SkipWaitOnUpdate
 	resp.Diagnostics.Append(resp.State.Set(ctx, newSearchNodeModel)...)
 }
 
@@ -129,7 +131,8 @@ func (r *searchDeploymentRS) Update(ctx context.Context, req resource.UpdateRequ
 	projectID := searchDeploymentPlan.ProjectID.ValueString()
 	clusterName := searchDeploymentPlan.ClusterName.ValueString()
 	searchDeploymentReq := NewSearchDeploymentReq(ctx, &searchDeploymentPlan)
-	if _, _, err := connV2.AtlasSearchApi.UpdateAtlasSearchDeployment(ctx, projectID, clusterName, &searchDeploymentReq).Execute(); err != nil {
+	deploymentResp, _, err := connV2.AtlasSearchApi.UpdateAtlasSearchDeployment(ctx, projectID, clusterName, &searchDeploymentReq).Execute()
+	if err != nil {
 		resp.Diagnostics.AddError("error during search deployment update", err.Error())
 		return
 	}
@@ -139,17 +142,21 @@ func (r *searchDeploymentRS) Update(ctx context.Context, req resource.UpdateRequ
 	if resp.Diagnostics.HasError() {
 		return
 	}
-	deploymentResp, err := WaitSearchNodeStateTransition(ctx, projectID, clusterName, connV2.AtlasSearchApi,
-		retryTimeConfig(updateTimeout, minTimeoutCreateUpdate))
-	if err != nil {
-		resp.Diagnostics.AddError("error during search deployment update", err.Error())
-		return
+	if !searchDeploymentPlan.SkipWaitOnUpdate.ValueBool() {
+		deploymentResp, err = WaitSearchNodeStateTransition(ctx, projectID, clusterName, connV2.AtlasSearchApi,
+			retryTimeConfig(updateTimeout, minTimeoutCreateUpdate))
+		if err != nil {
+			resp.Diagnostics.AddError("error during search deployment update", err.Error())
+			return
+		}
 	}
+
 	newSearchNodeModel, diagnostics := NewTFSearchDeployment(ctx, clusterName, deploymentResp, &searchDeploymentPlan.Timeouts, false)
 	resp.Diagnostics.Append(diagnostics...)
 	if resp.Diagnostics.HasError() {
 		return
 	}
+	newSearchNodeModel.SkipWaitOnUpdate = searchDeploymentPlan.SkipWaitOnUpdate
 	resp.Diagnostics.Append(resp.State.Set(ctx, newSearchNodeModel)...)
 }
 

internal/service/searchdeployment/resource_migration_test.go

@@ -16,7 +16,7 @@ func TestMigSearchDeployment_basic(t *testing.T) {
 		clusterName     = acc.RandomClusterName()
 		instanceSize    = "S30_HIGHCPU_NVME"
 		searchNodeCount = 3
-		config          = configBasic(projectID, clusterName, instanceSize, searchNodeCount)
+		config          = configBasic(projectID, clusterName, instanceSize, searchNodeCount, false)
 	)
 	mig.SkipIfVersionBelow(t, "1.32.0") // enabled_for_search_nodes introduced in this version
 	resource.ParallelTest(t, resource.TestCase{

internal/service/searchdeployment/resource_schema.go

@@ -63,6 +63,10 @@ func ResourceSchema(ctx context.Context) schema.Schema {
 				Update: true,
 				Delete: true,
 			}),
+			"skip_wait_on_update": schema.BoolAttribute{
+				Description: "If true, the resource update is executed without waiting until the [state](#state_name-1) is `IDLE`, making the operation faster. This might cause update errors to go unnoticed and lead to non-empty plans at the next terraform execution.",
+				Optional:    true,
+			},
 			"encryption_at_rest_provider": schema.StringAttribute{
 				Computed:            true,
 				MarkdownDescription: "Cloud service provider that manages your customer keys to provide an additional layer of Encryption At Rest for the cluster.",
@@ -78,6 +82,7 @@ type TFSearchDeploymentRSModel struct {
 	Specs                    types.List     `tfsdk:"specs"`
 	StateName                types.String   `tfsdk:"state_name"`
 	Timeouts                 timeouts.Value `tfsdk:"timeouts"`
+	SkipWaitOnUpdate         types.Bool     `tfsdk:"skip_wait_on_update"`
 	EncryptionAtRestProvider types.String   `tfsdk:"encryption_at_rest_provider"`
 }
 

internal/service/searchdeployment/resource_test.go

@@ -18,17 +18,26 @@ const (
 
 func TestAccSearchDeployment_basic(t *testing.T) {
 	var (
-		projectID   = acc.ProjectIDExecution(t)
-		clusterName = acc.RandomClusterName()
+		projectID, clusterName = acc.ProjectIDExecutionWithCluster(t, 6)
+		updateStep             = newSearchNodeTestStep(resourceID, projectID, clusterName, "S30_HIGHCPU_NVME", 4)
+		updateStepNoWait       = configBasic(projectID, clusterName, "S30_HIGHCPU_NVME", 4, true)
 	)
 	resource.ParallelTest(t, resource.TestCase{
 		PreCheck:                 func() { acc.PreCheckBasic(t) },
 		ProtoV6ProviderFactories: acc.TestAccProviderV6Factories,
 		CheckDestroy:             checkDestroy,
 		Steps: []resource.TestStep{
 			newSearchNodeTestStep(resourceID, projectID, clusterName, "S20_HIGHCPU_NVME", 3),
-			newSearchNodeTestStep(resourceID, projectID, clusterName, "S30_HIGHCPU_NVME", 4),
+			// Do a no-wait update then expect next step to wait for the update to complete
+			// We cannot check the state_name as the response of a PATCH can be IDLE
 			{
+				Config: updateStepNoWait,
+				Check:  updateStep.Check,
+			},
+			// Changes: skip_wait_on_update true -> null
+			updateStep,
+			{
+				Config:            updateStep.Config,
 				ResourceName:      resourceID,
 				ImportStateIdFunc: importStateIDFunc(resourceID),
 				ImportState:       true,
@@ -72,7 +81,7 @@ func newSearchNodeTestStep(resourceName, projectID, clusterName, instanceSize st
 	resourceChecks := searchNodeChecks(resourceName, clusterName, instanceSize, searchNodeCount)
 	dataSourceChecks := searchNodeChecks(dataSourceID, clusterName, instanceSize, searchNodeCount)
 	return resource.TestStep{
-		Config: configBasic(projectID, clusterName, instanceSize, searchNodeCount),
+		Config: configBasic(projectID, clusterName, instanceSize, searchNodeCount, false),
 		Check:  resource.ComposeAggregateTestCheckFunc(append(resourceChecks, dataSourceChecks...)...),
 	}
 }
@@ -90,27 +99,32 @@ func searchNodeChecks(targetName, clusterName, instanceSize string, searchNodeCo
 	}
 }
 
-func configBasic(projectID, clusterName, instanceSize string, searchNodeCount int) string {
+func configBasic(projectID, clusterName, instanceSize string, searchNodeCount int, skipWaitOnUpdate bool) string {
 	clusterConfig := acc.ConfigBasicDedicated(projectID, clusterName, "")
+	var skipWaitOnUpdateStr string
+	if skipWaitOnUpdate {
+		skipWaitOnUpdateStr = fmt.Sprintf("skip_wait_on_update = %t", skipWaitOnUpdate)
+	}
 	return fmt.Sprintf(`
 		%[1]s
 
 		resource "mongodbatlas_search_deployment" "test" {
 			project_id = %[2]q
-			cluster_name = mongodbatlas_advanced_cluster.test.name
+			cluster_name = mongodbatlas_advanced_cluster.test.name # ensure dependency on cluster
 			specs = [
 				{
 					instance_size = %[3]q
 					node_count = %[4]d
 				}
 			]
+			%[5]s
 		}
 
 		data "mongodbatlas_search_deployment" "test" {
 			project_id = mongodbatlas_search_deployment.test.project_id
 			cluster_name = mongodbatlas_search_deployment.test.cluster_name
 		}
-	`, clusterConfig, projectID, instanceSize, searchNodeCount)
+	`, clusterConfig, projectID, instanceSize, searchNodeCount, skipWaitOnUpdateStr)
 }
 
 func configSearchDeployment(projectID, clusterNameRef, instanceSize string, searchNodeCount int) string {

templates/resources/search_deployment.md.tmpl

@@ -19,4 +19,6 @@ Search node resource can be imported using the project ID and cluster name, in t
 $ terraform import mongodbatlas_search_deployment.test 650972848269185c55f40ca1-Cluster0
 ```
 
+After an import, a non-empty plan is expected if the configuration defines the `skip_wait_on_update` attribute. However, the update will not have any effect on the search deployment since `skip_wait_on_update` only relates to the update operations wait time.
+
 For more information see: [MongoDB Atlas API - Search Node](https://www.mongodb.com/docs/atlas/reference/api-resources-spec/#tag/Atlas-Search/operation/createAtlasSearchDeployment) Documentation.