Add support for IGM/RMIG All-Instances Configuration (#6041) (#4506)

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/6041.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: added field `all_instances_config` to `google_compute_instance_group_manager` and `google_compute_region_instance_group_manager` (Beta)
+```

google-beta/resource_compute_instance_group_manager.go

@@ -27,7 +27,6 @@ func resourceComputeInstanceGroupManager() *schema.Resource {
 			Update: schema.DefaultTimeout(15 * time.Minute),
 			Delete: schema.DefaultTimeout(15 * time.Minute),
 		},
-
 		Schema: map[string]*schema.Schema{
 			"base_instance_name": {
 				Type:        schema.TypeString,
@@ -267,7 +266,30 @@ func resourceComputeInstanceGroupManager() *schema.Resource {
 					},
 				},
 			},
-
+			"all_instances_config": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				MaxItems:    1,
+				Description: `Specifies configuration that overrides the instance template configuration for the group.`,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"metadata": {
+							Type:        schema.TypeMap,
+							Optional:    true,
+							Elem:        &schema.Schema{Type: schema.TypeString},
+							Set:         schema.HashString,
+							Description: `The metadata key-value pairs that you want to patch onto the instance. For more information, see Project and instance metadata,`,
+						},
+						"labels": {
+							Type:        schema.TypeMap,
+							Optional:    true,
+							Elem:        &schema.Schema{Type: schema.TypeString},
+							Set:         schema.HashString,
+							Description: `The label key-value pairs that you want to patch onto the instance,`,
+						},
+					},
+				},
+			},
 			"wait_for_instances": {
 				Type:        schema.TypeBool,
 				Optional:    true,
@@ -279,7 +301,8 @@ func resourceComputeInstanceGroupManager() *schema.Resource {
 				Optional:     true,
 				Default:      "STABLE",
 				ValidateFunc: validation.StringInSlice([]string{"STABLE", "UPDATED"}, false),
-				Description:  `When used with wait_for_instances specifies the status to wait for. When STABLE is specified this resource will wait until the instances are stable before returning. When UPDATED is set, it will wait for the version target to be reached and any per instance configs to be effective as well as all instances to be stable before returning.`,
+
+				Description: `When used with wait_for_instances specifies the status to wait for. When STABLE is specified this resource will wait until the instances are stable before returning. When UPDATED is set, it will wait for the version target to be reached and any per instance configs to be effective and all instances configs to be effective as well as all instances to be stable before returning.`,
 			},
 			"stateful_disk": {
 				Type:        schema.TypeSet,
@@ -333,6 +356,20 @@ func resourceComputeInstanceGroupManager() *schema.Resource {
 								},
 							},
 						},
+						"all_instances_config": {
+							Type:        schema.TypeList,
+							Computed:    true,
+							Description: `Status of all-instances configuration on the group.`,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"effective": {
+										Type:        schema.TypeBool,
+										Computed:    true,
+										Description: `A bit indicating whether this configuration has been applied to all managed instances in the group.`,
+									},
+								},
+							},
+						},
 						"stateful": {
 							Type:        schema.TypeList,
 							Computed:    true,
@@ -423,6 +460,7 @@ func resourceComputeInstanceGroupManagerCreate(d *schema.ResourceData, meta inte
 		AutoHealingPolicies: expandAutoHealingPolicies(d.Get("auto_healing_policies").([]interface{})),
 		Versions:            expandVersions(d.Get("version").([]interface{})),
 		UpdatePolicy:        expandUpdatePolicy(d.Get("update_policy").([]interface{})),
+		AllInstancesConfig:  expandAllInstancesConfig(nil, d.Get("all_instances_config").([]interface{})),
 		StatefulPolicy:      expandStatefulPolicy(d.Get("stateful_disk").(*schema.Set).List()),
 		// Force send TargetSize to allow a value of 0.
 		ForceSendFields: []string{"TargetSize"},
@@ -630,6 +668,11 @@ func resourceComputeInstanceGroupManagerRead(d *schema.ResourceData, meta interf
 	if err = d.Set("update_policy", flattenUpdatePolicy(manager.UpdatePolicy)); err != nil {
 		return fmt.Errorf("Error setting update_policy in state: %s", err.Error())
 	}
+	if manager.AllInstancesConfig != nil {
+		if err = d.Set("all_instances_config", flattenAllInstancesConfig(manager.AllInstancesConfig)); err != nil {
+			return fmt.Errorf("Error setting all_instances_config in state: %s", err.Error())
+		}
+	}
 	if err = d.Set("status", flattenStatus(manager.Status)); err != nil {
 		return fmt.Errorf("Error setting status in state: %s", err.Error())
 	}
@@ -695,6 +738,16 @@ func resourceComputeInstanceGroupManagerUpdate(d *schema.ResourceData, meta inte
 		change = true
 	}
 
+	if d.HasChange("all_instances_config") {
+		oldAic, newAic := d.GetChange("all_instances_config")
+		if newAic == nil || len(newAic.([]interface{})) == 0 {
+			updatedManager.NullFields = append(updatedManager.NullFields, "AllInstancesConfig")
+		} else {
+			updatedManager.AllInstancesConfig = expandAllInstancesConfig(oldAic.([]interface{}), newAic.([]interface{}))
+		}
+		change = true
+	}
+
 	if d.HasChange("stateful_disk") {
 		updatedManager.StatefulPolicy = expandStatefulPolicy(d.Get("stateful_disk").(*schema.Set).List())
 		change = true
@@ -838,7 +891,7 @@ func resourceComputeInstanceGroupManagerDelete(d *schema.ResourceData, meta inte
 func computeIGMWaitForInstanceStatus(d *schema.ResourceData, meta interface{}) error {
 	waitForUpdates := d.Get("wait_for_instances_status").(string) == "UPDATED"
 	conf := resource.StateChangeConf{
-		Pending: []string{"creating", "error", "updating per instance configs", "reaching version target"},
+		Pending: []string{"creating", "error", "updating per instance configs", "reaching version target", "updating all instances config"},
 		Target:  []string{"created"},
 		Refresh: waitForInstancesRefreshFunc(getManager, waitForUpdates, d, meta),
 		Timeout: d.Timeout(schema.TimeoutCreate),
@@ -1020,13 +1073,68 @@ func flattenUpdatePolicy(updatePolicy *compute.InstanceGroupManagerUpdatePolicy)
 	return results
 }
 
+func expandAllInstancesConfig(old []interface{}, new []interface{}) *compute.InstanceGroupManagerAllInstancesConfig {
+	var properties *compute.InstancePropertiesPatch
+	for _, raw := range new {
+		properties = &compute.InstancePropertiesPatch{}
+		data := raw.(map[string]interface{})
+		properties.Metadata = convertStringMap(data["metadata"].(map[string]interface{}))
+		if len(properties.Metadata) == 0 {
+			properties.NullFields = append(properties.NullFields, "Metadata")
+		}
+		properties.Labels = convertStringMap(data["labels"].(map[string]interface{}))
+		if len(properties.Labels) == 0 {
+			properties.NullFields = append(properties.NullFields, "Labels")
+		}
+	}
+
+	if properties != nil {
+		for _, raw := range old {
+			data := raw.(map[string]interface{})
+			for k := range data["metadata"].(map[string]interface{}) {
+				if _, exist := properties.Metadata[k]; !exist {
+					properties.NullFields = append(properties.NullFields, fmt.Sprintf("Metadata.%s", k))
+				}
+			}
+			for k := range data["labels"].(map[string]interface{}) {
+				if _, exist := properties.Labels[k]; !exist {
+					properties.NullFields = append(properties.NullFields, fmt.Sprintf("Labels.%s", k))
+				}
+			}
+		}
+	}
+	if properties != nil {
+		allInstancesConfig := &compute.InstanceGroupManagerAllInstancesConfig{}
+		allInstancesConfig.Properties = properties
+		return allInstancesConfig
+	} else {
+		return nil
+	}
+}
+
+func flattenAllInstancesConfig(allInstancesConfig *compute.InstanceGroupManagerAllInstancesConfig) []map[string]interface{} {
+	results := []map[string]interface{}{}
+	props := map[string]interface{}{}
+	if len(allInstancesConfig.Properties.Metadata) > 0 {
+		props["metadata"] = allInstancesConfig.Properties.Metadata
+	}
+	if len(allInstancesConfig.Properties.Labels) > 0 {
+		props["labels"] = allInstancesConfig.Properties.Labels
+	}
+	results = append(results, props)
+	return results
+}
+
 func flattenStatus(status *compute.InstanceGroupManagerStatus) []map[string]interface{} {
 	results := []map[string]interface{}{}
 	data := map[string]interface{}{
 		"is_stable":      status.IsStable,
 		"stateful":       flattenStatusStateful(status.Stateful),
 		"version_target": flattenStatusVersionTarget(status.VersionTarget),
 	}
+	if status.AllInstancesConfig != nil {
+		data["all_instances_config"] = flattenStatusAllInstancesConfig(status.AllInstancesConfig)
+	}
 	results = append(results, data)
 	return results
 }
@@ -1059,6 +1167,15 @@ func flattenStatusVersionTarget(versionTarget *compute.InstanceGroupManagerStatu
 	return results
 }
 
+func flattenStatusAllInstancesConfig(allInstancesConfig *compute.InstanceGroupManagerStatusAllInstancesConfig) []map[string]interface{} {
+	results := []map[string]interface{}{}
+	data := map[string]interface{}{
+		"effective": allInstancesConfig.Effective,
+	}
+	results = append(results, data)
+	return results
+}
+
 func resourceInstanceGroupManagerStateImporter(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
 	if err := d.Set("wait_for_instances", false); err != nil {
 		return nil, fmt.Errorf("Error setting wait_for_instances: %s", err)

google-beta/resource_compute_instance_group_manager_test.go

@@ -608,6 +608,14 @@ resource "google_compute_instance_group_manager" "igm-update" {
     name = "customhttp"
     port = 8080
   }
+  all_instances_config {
+    metadata = {
+      foo = "bar"
+    }
+    labels = {
+      doo = "dad"
+    }
+  }
 }
 `, template, target, description, igm)
 }
@@ -698,6 +706,15 @@ resource "google_compute_instance_group_manager" "igm-update" {
     name = "customhttps"
     port = 8443
   }
+
+  all_instances_config {
+    metadata = {
+      doo = "dad"
+    }
+    labels = {
+      foo = "bar"
+    }
+  }
 }
 `, template1, target1, target2, template2, description, igm)
 }
@@ -1579,11 +1596,26 @@ resource "google_compute_instance_group_manager" "igm-basic" {
   name        = "%s"
   version {
     instance_template = google_compute_instance_template.igm-basic.self_link
-    name              = "prod"
+    name              = "prod2"
   }
   target_pools       = [google_compute_target_pool.igm-basic.self_link]
   base_instance_name = "tf-test-igm-basic"
   zone               = "us-central1-c"
+  update_policy {
+    type                    = "PROACTIVE"
+    minimal_action          = "REPLACE"
+    replacement_method      = "RECREATE"
+    max_surge_fixed         = 0
+    max_unavailable_percent = 50
+  }
+  all_instances_config {
+    metadata = {
+      doo = "dad"
+    }
+    labels = {
+      foo = "bar"
+    }
+  }
   wait_for_instances = true
   wait_for_instances_status = "UPDATED"
 }

google-beta/resource_compute_region_instance_group_manager.go

@@ -180,7 +180,8 @@ func resourceComputeRegionInstanceGroupManager() *schema.Resource {
 				Optional:     true,
 				Default:      "STABLE",
 				ValidateFunc: validation.StringInSlice([]string{"STABLE", "UPDATED"}, false),
-				Description:  `When used with wait_for_instances specifies the status to wait for. When STABLE is specified this resource will wait until the instances are stable before returning. When UPDATED is set, it will wait for the version target to be reached and any per instance configs to be effective as well as all instances to be stable before returning.`,
+
+				Description: `When used with wait_for_instances specifies the status to wait for. When STABLE is specified this resource will wait until the instances are stable before returning. When UPDATED is set, it will wait for the version target to be reached and any per instance configs to be effective and all instances configs to be effective as well as all instances to be stable before returning.`,
 			},
 
 			"auto_healing_policies": {
@@ -312,7 +313,30 @@ func resourceComputeRegionInstanceGroupManager() *schema.Resource {
 					},
 				},
 			},
-
+			"all_instances_config": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				MaxItems:    1,
+				Description: `Specifies configuration that overrides the instance template configuration for the group.`,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"metadata": {
+							Type:        schema.TypeMap,
+							Optional:    true,
+							Elem:        &schema.Schema{Type: schema.TypeString},
+							Set:         schema.HashString,
+							Description: `The metadata key-value pairs that you want to patch onto the instance. For more information, see Project and instance metadata,`,
+						},
+						"labels": {
+							Type:        schema.TypeMap,
+							Optional:    true,
+							Elem:        &schema.Schema{Type: schema.TypeString},
+							Set:         schema.HashString,
+							Description: `The label key-value pairs that you want to patch onto the instance,`,
+						},
+					},
+				},
+			},
 			"stateful_disk": {
 				Type:        schema.TypeSet,
 				Optional:    true,
@@ -361,6 +385,20 @@ func resourceComputeRegionInstanceGroupManager() *schema.Resource {
 								},
 							},
 						},
+						"all_instances_config": {
+							Type:        schema.TypeList,
+							Computed:    true,
+							Description: `Status of all-instances configuration on the group.`,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"effective": {
+										Type:        schema.TypeBool,
+										Computed:    true,
+										Description: `A bit indicating whether this configuration has been applied to all managed instances in the group.`,
+									},
+								},
+							},
+						},
 						"stateful": {
 							Type:        schema.TypeList,
 							Computed:    true,
@@ -424,6 +462,7 @@ func resourceComputeRegionInstanceGroupManagerCreate(d *schema.ResourceData, met
 		AutoHealingPolicies: expandAutoHealingPolicies(d.Get("auto_healing_policies").([]interface{})),
 		Versions:            expandVersions(d.Get("version").([]interface{})),
 		UpdatePolicy:        expandRegionUpdatePolicy(d.Get("update_policy").([]interface{})),
+		AllInstancesConfig:  expandAllInstancesConfig(nil, d.Get("all_instances_config").([]interface{})),
 		DistributionPolicy:  expandDistributionPolicy(d),
 		StatefulPolicy:      expandStatefulPolicy(d.Get("stateful_disk").(*schema.Set).List()),
 		// Force send TargetSize to allow size of 0.
@@ -461,7 +500,7 @@ func resourceComputeRegionInstanceGroupManagerCreate(d *schema.ResourceData, met
 func computeRIGMWaitForInstanceStatus(d *schema.ResourceData, meta interface{}) error {
 	waitForUpdates := d.Get("wait_for_instances_status").(string) == "UPDATED"
 	conf := resource.StateChangeConf{
-		Pending: []string{"creating", "error", "updating per instance configs", "reaching version target"},
+		Pending: []string{"creating", "error", "updating per instance configs", "reaching version target", "updating all instances config"},
 		Target:  []string{"created"},
 		Refresh: waitForInstancesRefreshFunc(getRegionalManager, waitForUpdates, d, meta),
 		Timeout: d.Timeout(schema.TimeoutCreate),
@@ -520,6 +559,12 @@ func waitForInstancesRefreshFunc(f getInstanceManagerFunc, waitForUpdates bool,
 				if !m.Status.VersionTarget.IsReached {
 					return false, "reaching version target", nil
 				}
+				if !m.Status.VersionTarget.IsReached {
+					return false, "reaching version target", nil
+				}
+				if !m.Status.AllInstancesConfig.Effective {
+					return false, "updating all instances config", nil
+				}
 			}
 			return true, "created", nil
 		} else {
@@ -595,6 +640,11 @@ func resourceComputeRegionInstanceGroupManagerRead(d *schema.ResourceData, meta
 	if err := d.Set("update_policy", flattenRegionUpdatePolicy(manager.UpdatePolicy)); err != nil {
 		return fmt.Errorf("Error setting update_policy in state: %s", err.Error())
 	}
+	if manager.AllInstancesConfig != nil {
+		if err = d.Set("all_instances_config", flattenAllInstancesConfig(manager.AllInstancesConfig)); err != nil {
+			return fmt.Errorf("Error setting all_instances_config in state: %s", err.Error())
+		}
+	}
 	if err = d.Set("stateful_disk", flattenStatefulPolicy(manager.StatefulPolicy)); err != nil {
 		return fmt.Errorf("Error setting stateful_disk in state: %s", err.Error())
 	}
@@ -657,6 +707,16 @@ func resourceComputeRegionInstanceGroupManagerUpdate(d *schema.ResourceData, met
 		change = true
 	}
 
+	if d.HasChange("all_instances_config") {
+		oldAic, newAic := d.GetChange("all_instances_config")
+		if newAic == nil || len(newAic.([]interface{})) == 0 {
+			updatedManager.NullFields = append(updatedManager.NullFields, "AllInstancesConfig")
+		} else {
+			updatedManager.AllInstancesConfig = expandAllInstancesConfig(oldAic.([]interface{}), newAic.([]interface{}))
+		}
+		change = true
+	}
+
 	if d.HasChange("stateful_disk") {
 		updatedManager.StatefulPolicy = expandStatefulPolicy(d.Get("stateful_disk").(*schema.Set).List())
 		change = true