Add remove_instance_on_destroy option to per-compute instance config resources

.changelog/9588.txt

@@ -0,0 +1,6 @@
+```release-note:bug
+compute: added `remove_instance_on_destroy` option to `google_compute_per_instance_config` resource
+```
+```release-note:bug
+compute: added `remove_instance_on_destroy` option to `google_compute_region_per_instance_config` resource
+```

google/services/compute/resource_compute_disk.go

@@ -19,6 +19,7 @@ package compute
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log"
 	"reflect"
@@ -1356,7 +1357,8 @@ func resourceComputeDiskDelete(d *schema.ResourceData, meta interface{}) error {
 			err = ComputeOperationWaitTime(config, op, call.project,
 				fmt.Sprintf("Detaching disk from %s/%s/%s", call.project, call.zone, call.instance), userAgent, d.Timeout(schema.TimeoutDelete))
 			if err != nil {
-				if opErr, ok := err.(ComputeOperationError); ok && len(opErr.Errors) == 1 && opErr.Errors[0].Code == "RESOURCE_NOT_FOUND" {
+				var opErr ComputeOperationError
+				if errors.As(err, &opErr) && len(opErr.Errors) == 1 && opErr.Errors[0].Code == "RESOURCE_NOT_FOUND" {
 					log.Printf("[WARN] instance %q was deleted while awaiting detach", call.instance)
 					continue
 				}

google/services/compute/resource_compute_per_instance_config.go

@@ -191,6 +191,13 @@ Default is 'REPLACE'. Possible values are:
 * RESTART
 * REFRESH
 * NONE`,
+			},
+			"remove_instance_on_destroy": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				Default:  false,
+				Description: `When true, deleting this config will immediately remove the underlying instance.
+When false, deleting this config will use the behavior as determined by remove_instance_on_destroy.`,
 			},
 			"remove_instance_state_on_destroy": {
 				Type:     schema.TypeBool,
@@ -393,6 +400,11 @@ func resourceComputePerInstanceConfigRead(d *schema.ResourceData, meta interface
 			return fmt.Errorf("Error setting most_disruptive_allowed_action: %s", err)
 		}
 	}
+	if _, ok := d.GetOkExists("remove_instance_on_destroy"); !ok {
+		if err := d.Set("remove_instance_on_destroy", false); err != nil {
+			return fmt.Errorf("Error setting remove_instance_on_destroy: %s", err)
+		}
+	}
 	if _, ok := d.GetOkExists("remove_instance_state_on_destroy"); !ok {
 		if err := d.Set("remove_instance_state_on_destroy", false); err != nil {
 			return fmt.Errorf("Error setting remove_instance_state_on_destroy: %s", err)
@@ -567,14 +579,31 @@ func resourceComputePerInstanceConfigDelete(d *schema.ResourceData, meta interfa
 	transport_tpg.MutexStore.Lock(lockName)
 	defer transport_tpg.MutexStore.Unlock(lockName)
 
-	url, err := tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/zones/{{zone}}/instanceGroupManagers/{{instance_group_manager}}/deletePerInstanceConfigs")
+	var url string
+	if d.Get("remove_instance_on_destroy").(bool) {
+		url, err = tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/zones/{{zone}}/instanceGroupManagers/{{instance_group_manager}}/deleteInstances")
+	} else {
+		url, err = tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/zones/{{zone}}/instanceGroupManagers/{{instance_group_manager}}/deletePerInstanceConfigs")
+	}
 	if err != nil {
 		return err
 	}
 
 	var obj map[string]interface{}
-	obj = map[string]interface{}{
-		"names": [1]string{d.Get("name").(string)},
+	if d.Get("remove_instance_on_destroy").(bool) {
+		// Instance name in deleteInstances request must include zone
+		instanceName, err := tpgresource.ReplaceVars(d, config, "zones/{{zone}}/instances/{{name}}")
+		if err != nil {
+			return err
+		}
+
+		obj = map[string]interface{}{
+			"instances": [1]string{instanceName},
+		}
+	} else {
+		obj = map[string]interface{}{
+			"names": [1]string{d.Get("name").(string)},
+		}
 	}
 	log.Printf("[DEBUG] Deleting PerInstanceConfig %q", d.Id())
 
@@ -599,8 +628,14 @@ func resourceComputePerInstanceConfigDelete(d *schema.ResourceData, meta interfa
 		return err
 	}
 
-	// Potentially delete the state managed by this config
-	if d.Get("remove_instance_state_on_destroy").(bool) {
+	if d.Get("remove_instance_on_destroy").(bool) {
+		err = transport_tpg.PollingWaitTime(resourceComputePerInstanceConfigInstancePollRead(d, meta, d.Get("name").(string)), PollCheckInstanceConfigInstanceDeleted, "Deleting PerInstanceConfig", d.Timeout(schema.TimeoutDelete), 1)
+		if err != nil {
+			return fmt.Errorf("Error waiting for instance delete on PerInstanceConfig %q: %s", d.Id(), err)
+		}
+	} else if d.Get("remove_instance_state_on_destroy").(bool) {
+		// Potentially delete the state managed by this config
+
 		// Instance name in applyUpdatesToInstances request must include zone
 		instanceName, err := tpgresource.ReplaceVars(d, config, "zones/{{zone}}/instances/{{name}}")
 		if err != nil {
@@ -674,6 +709,9 @@ func resourceComputePerInstanceConfigImport(d *schema.ResourceData, meta interfa
 	if err := d.Set("most_disruptive_allowed_action", "REPLACE"); err != nil {
 		return nil, fmt.Errorf("Error setting most_disruptive_allowed_action: %s", err)
 	}
+	if err := d.Set("remove_instance_on_destroy", false); err != nil {
+		return nil, fmt.Errorf("Error setting remove_instance_on_destroy: %s", err)
+	}
 	if err := d.Set("remove_instance_state_on_destroy", false); err != nil {
 		return nil, fmt.Errorf("Error setting remove_instance_state_on_destroy: %s", err)
 	}

google/services/compute/resource_compute_per_instance_config_test.go

@@ -171,6 +171,67 @@ func TestAccComputePerInstanceConfig_statefulIps(t *testing.T) {
 	})
 }
 
+func TestAccComputePerInstanceConfig_removeInstanceOnDestroy(t *testing.T) {
+	t.Parallel()
+
+	igmName := fmt.Sprintf("tf-test-igm-%s", acctest.RandString(t, 10))
+	context := map[string]interface{}{
+		"random_suffix": acctest.RandString(t, 10),
+		"igm_name":      igmName,
+		"config_name":   fmt.Sprintf("instance-%s", acctest.RandString(t, 10)),
+		"config_name2":  fmt.Sprintf("instance-%s", acctest.RandString(t, 10)),
+		"network":       fmt.Sprintf("tf-test-igm-%s", acctest.RandString(t, 10)),
+		"subnetwork":    fmt.Sprintf("tf-test-igm-%s", acctest.RandString(t, 10)),
+		"address1":      fmt.Sprintf("tf-test-igm-address%s", acctest.RandString(t, 10)),
+		"address2":      fmt.Sprintf("tf-test-igm-address%s", acctest.RandString(t, 10)),
+	}
+	igmId := fmt.Sprintf("projects/%s/zones/%s/instanceGroupManagers/%s",
+		envvar.GetTestProjectFromEnv(), envvar.GetTestZoneFromEnv(), igmName)
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputePerInstanceConfig_removeInstanceOnDestroyBefore(context),
+			},
+			{
+				ResourceName:            "google_compute_per_instance_config.config_one",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"remove_instance_on_destroy", "zone"},
+			},
+			{
+				ResourceName:            "google_compute_per_instance_config.config_two",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"remove_instance_on_destroy", "zone"},
+			},
+			{
+				Config: testAccComputePerInstanceConfig_removeInstanceOnDestroyAfter(context),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputePerInstanceConfigDestroyed(t, igmId, context["config_name"].(string)),
+					testAccCheckComputePerInstanceConfigInstanceDestroyed(t, igmId, context["config_name"].(string)),
+				),
+			},
+			{
+				ResourceName:            "google_compute_per_instance_config.config_two",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"remove_instance_on_destroy", "zone"},
+			},
+			{
+				// delete all configs
+				Config: testAccComputePerInstanceConfig_igm(context),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputePerInstanceConfigDestroyed(t, igmId, context["config_name2"].(string)),
+					testAccCheckComputePerInstanceConfigInstanceDestroyed(t, igmId, context["config_name2"].(string)),
+				),
+			},
+		},
+	})
+}
+
 func testAccComputePerInstanceConfig_statefulBasic(context map[string]interface{}) string {
 	return acctest.Nprintf(`
 resource "google_compute_per_instance_config" "default" {
@@ -341,6 +402,109 @@ resource "google_compute_instance_group_manager" "igm" {
 `, context)
 }
 
+func testAccComputePerInstanceConfig_removeInstanceOnDestroyBefore(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_network" "default" {
+  name = "%{network}"
+}
+
+resource "google_compute_subnetwork" "default" {
+  name          = "%{subnetwork}"
+  ip_cidr_range = "10.0.0.0/16"
+  region        = "us-central1"
+  network       = google_compute_network.default.id
+}
+
+resource "google_compute_address" "static_internal_ip" {
+  name         = "%{address1}"
+  address_type = "INTERNAL"
+}
+
+resource "google_compute_address" "static_external_ip" {
+  name         = "%{address2}"
+  address_type = "EXTERNAL"
+}
+
+resource "google_compute_per_instance_config" "config_one" {
+  instance_group_manager = google_compute_instance_group_manager.igm.name
+  name = "%{config_name}"
+  remove_instance_on_destroy = true
+  preserved_state {
+    metadata = {
+      asdf = "config-one"
+    }
+    disk {
+      device_name = "my-stateful-disk1"
+      source      = google_compute_disk.disk.id
+    }
+
+    disk {
+      device_name = "my-stateful-disk2"
+      source      = google_compute_disk.disk1.id
+    }
+    internal_ip {
+      ip_address {
+        address = google_compute_address.static_internal_ip.self_link
+      }
+      auto_delete    = "NEVER"
+      interface_name = "nic0"
+    }
+    external_ip {
+      ip_address {
+        address = google_compute_address.static_external_ip.self_link
+      }
+      auto_delete    = "NEVER"
+      interface_name = "nic0"
+    }
+  }
+}
+
+resource "google_compute_disk" "disk" {
+  name  = "test-disk-%{random_suffix}"
+  type  = "pd-ssd"
+  zone  = google_compute_instance_group_manager.igm.zone
+  image = "debian-8-jessie-v20170523"
+  physical_block_size_bytes = 4096
+}
+
+resource "google_compute_disk" "disk1" {
+  name  = "test-disk2-%{random_suffix}"
+  type  = "pd-ssd"
+  zone  = google_compute_instance_group_manager.igm.zone
+  image = "debian-cloud/debian-11"
+  physical_block_size_bytes = 4096
+}
+
+resource "google_compute_per_instance_config" "config_two" {
+	zone = google_compute_instance_group_manager.igm.zone
+	instance_group_manager = google_compute_instance_group_manager.igm.name
+	name = "%{config_name2}"
+	remove_instance_on_destroy = true
+	preserved_state {
+		metadata = {
+			asdf = "config-two"
+		}
+	}
+}
+`, context) + testAccComputePerInstanceConfig_igm(context)
+}
+
+func testAccComputePerInstanceConfig_removeInstanceOnDestroyAfter(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_per_instance_config" "config_two" {
+	zone = google_compute_instance_group_manager.igm.zone
+	instance_group_manager = google_compute_instance_group_manager.igm.name
+	name = "%{config_name2}"
+	remove_instance_on_destroy = true
+	preserved_state {
+		metadata = {
+			asdf = "config-two"
+		}
+	}
+}
+`, context) + testAccComputePerInstanceConfig_igm(context)
+}
+
 func testAccComputePerInstanceConfig_statefulIpsBasic(context map[string]interface{}) string {
 	return acctest.Nprintf(`
 resource "google_compute_network" "default" {
@@ -353,17 +517,17 @@ resource "google_compute_subnetwork" "default" {
   region        = "us-central1"
   network       = google_compute_network.default.id
 }
-	
+
 resource "google_compute_address" "static_internal_ip" {
   name         = "%{address1}"
   address_type = "INTERNAL"
 }
-	
+
 resource "google_compute_address" "static_external_ip" {
   name         = "%{address2}"
   address_type = "EXTERNAL"
 }
-	  
+
 resource "google_compute_per_instance_config" "default" {
   instance_group_manager = google_compute_instance_group_manager.igm.name
   name = "%{config_name}"
@@ -405,7 +569,7 @@ resource "google_compute_disk" "disk" {
   image = "debian-8-jessie-v20170523"
   physical_block_size_bytes = 4096
 }
-  
+
 resource "google_compute_disk" "disk1" {
   name  = "test-disk2-%{random_suffix}"
   type  = "pd-ssd"
@@ -428,17 +592,17 @@ resource "google_compute_subnetwork" "default" {
   region        = "us-central1"
   network       = google_compute_network.default.id
 }
-	
+
 resource "google_compute_address" "static_internal_ip" {
   name         = "%{address1}"
   address_type = "INTERNAL"
 }
-	
+
 resource "google_compute_address" "static_external_ip" {
   name         = "%{address2}"
   address_type = "EXTERNAL"
 }
-	  
+
 resource "google_compute_per_instance_config" "default" {
   instance_group_manager = google_compute_instance_group_manager.igm.name
   name = "%{config_name}"
@@ -480,7 +644,7 @@ resource "google_compute_disk" "disk" {
   image = "debian-8-jessie-v20170523"
   physical_block_size_bytes = 4096
 }
-  
+
 resource "google_compute_disk" "disk1" {
   name  = "test-disk2-%{random_suffix}"
   type  = "pd-ssd"
@@ -506,6 +670,48 @@ func testAccCheckComputePerInstanceConfigDestroyed(t *testing.T, igmId, configNa
 	}
 }
 
+// Checks that the instance with the given name was destroyed.
+func testAccCheckComputePerInstanceConfigInstanceDestroyed(t *testing.T, igmId, configName string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		foundNames, err := testAccComputePerInstanceConfigListInstances(t, igmId)
+		if err != nil {
+			return fmt.Errorf("unable to confirm instance with name %s was destroyed: %v", configName, err)
+		}
+		if _, ok := foundNames[configName]; ok {
+			return fmt.Errorf("instance with name %s still exists", configName)
+		}
+
+		return nil
+	}
+}
+
+func testAccComputePerInstanceConfigListInstances(t *testing.T, igmId string) (map[string]struct{}, error) {
+	config := acctest.GoogleProviderConfig(t)
+
+	url := fmt.Sprintf("%s%s/listManagedInstances", config.ComputeBasePath, igmId)
+	res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
+		Config:    config,
+		Method:    "POST",
+		RawURL:    url,
+		UserAgent: config.UserAgent,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	v, ok := res["managedInstances"]
+	if !ok || v == nil {
+		return nil, nil
+	}
+	items := v.([]interface{})
+	instances := make(map[string]struct{})
+	for _, item := range items {
+		instance := item.(map[string]interface{})
+		instances[fmt.Sprintf("%v", instance["name"])] = struct{}{}
+	}
+	return instances, nil
+}
+
 func testAccComputePerInstanceConfigListNames(t *testing.T, igmId string) (map[string]struct{}, error) {
 	config := acctest.GoogleProviderConfig(t)