Implement multiple version in instance group manager

google/resource_compute_instance_group_manager.go

@@ -33,10 +33,50 @@ func resourceComputeInstanceGroupManager() *schema.Resource {
 
 			"instance_template": &schema.Schema{
 				Type:             schema.TypeString,
-				Required:         true,
+				Optional:         true,
 				DiffSuppressFunc: compareSelfLinkRelativePaths,
 			},
 
+			"version": &schema.Schema{
+				Type:     schema.TypeList,
+				Optional: true,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"name": &schema.Schema{
+							Type:     schema.TypeString,
+							Required: true,
+						},
+
+						"instance_template": &schema.Schema{
+							Type:             schema.TypeString,
+							Required:         true,
+							DiffSuppressFunc: compareSelfLinkRelativePaths,
+						},
+
+						"target_size": &schema.Schema{
+							Type:     schema.TypeList,
+							Optional: true,
+							MaxItems: 1,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"fixed": &schema.Schema{
+										Type:     schema.TypeInt,
+										Optional: true,
+									},
+
+									"percent": &schema.Schema{
+										Type:         schema.TypeInt,
+										Optional:     true,
+										ValidateFunc: validation.IntBetween(0, 100),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+
 			"name": &schema.Schema{
 				Type:     schema.TypeString,
 				Required: true,
@@ -138,6 +178,7 @@ func resourceComputeInstanceGroupManager() *schema.Resource {
 					},
 				},
 			},
+
 			"rolling_update_policy": &schema.Schema{
 				Type:     schema.TypeList,
 				Optional: true,
@@ -192,6 +233,7 @@ func resourceComputeInstanceGroupManager() *schema.Resource {
 					},
 				},
 			},
+
 			"wait_for_instances": &schema.Schema{
 				Type:     schema.TypeBool,
 				Optional: true,
@@ -254,6 +296,7 @@ func resourceComputeInstanceGroupManagerCreate(d *schema.ResourceData, meta inte
 		NamedPorts:          getNamedPortsBeta(d.Get("named_port").([]interface{})),
 		TargetPools:         convertStringSet(d.Get("target_pools").(*schema.Set)),
 		AutoHealingPolicies: expandAutoHealingPolicies(d.Get("auto_healing_policies").([]interface{})),
+		Versions:            expandVersions(d.Get("version").([]interface{})),
 		// Force send TargetSize to allow a value of 0.
 		ForceSendFields: []string{"TargetSize"},
 	}
@@ -290,6 +333,31 @@ func flattenNamedPortsBeta(namedPorts []*computeBeta.NamedPort) []map[string]int
 
 }
 
+func flattenVersions(versions []*computeBeta.InstanceGroupManagerVersion) []map[string]interface{} {
+	result := make([]map[string]interface{}, 0, len(versions))
+	for _, version := range versions {
+		versionMap := make(map[string]interface{})
+		versionMap["name"] = version.Name
+		versionMap["instance_template"] = ConvertSelfLinkToV1(version.InstanceTemplate)
+		versionMap["target_size"] = flattenFixedOrPercent(version.TargetSize)
+		result = append(result, versionMap)
+	}
+
+	return result
+}
+
+func flattenFixedOrPercent(fixedOrPercent *computeBeta.FixedOrPercent) []map[string]interface{} {
+	result := make(map[string]interface{})
+	if value := fixedOrPercent.Percent; value > 0 {
+		result["percent"] = value
+	} else if value := fixedOrPercent.Fixed; value > 0 {
+		result["fixed"] = fixedOrPercent.Fixed
+	} else {
+		return []map[string]interface{}{}
+	}
+	return []map[string]interface{}{result}
+}
+
 func getManager(d *schema.ResourceData, meta interface{}) (*computeBeta.InstanceGroupManager, error) {
 	config := meta.(*Config)
 
@@ -352,6 +420,9 @@ func resourceComputeInstanceGroupManagerRead(d *schema.ResourceData, meta interf
 
 	d.Set("base_instance_name", manager.BaseInstanceName)
 	d.Set("instance_template", ConvertSelfLinkToV1(manager.InstanceTemplate))
+	if err := d.Set("version", flattenVersions(manager.Versions)); err != nil {
+		return err
+	}
 	d.Set("name", manager.Name)
 	d.Set("zone", GetResourceNameFromSelfLink(manager.Zone))
 	d.Set("description", manager.Description)
@@ -385,6 +456,63 @@ func resourceComputeInstanceGroupManagerRead(d *schema.ResourceData, meta interf
 	return nil
 }
 
+// Updates an instance group manager by applying an update strategy (REPLACE, RESTART) respecting a rolling update policy (availability settings,
+// interval between updates, and particularly, the type of update PROACTIVE or OPPORTUNISTIC because updates performed by API are considered
+// OPPORTUNISTIC by default)
+func performUpdate(config *Config, id string, updateStrategy string, rollingUpdatePolicy *computeBeta.InstanceGroupManagerUpdatePolicy, versions []*computeBeta.InstanceGroupManagerVersion, project string, zone string) error {
+	if updateStrategy == "RESTART" {
+		managedInstances, err := config.clientComputeBeta.InstanceGroupManagers.ListManagedInstances(project, zone, id).Do()
+		if err != nil {
+			return fmt.Errorf("Error getting instance group managers instances: %s", err)
+		}
+
+		managedInstanceCount := len(managedInstances.ManagedInstances)
+		instances := make([]string, managedInstanceCount)
+		for i, v := range managedInstances.ManagedInstances {
+			instances[i] = v.Instance
+		}
+
+		recreateInstances := &computeBeta.InstanceGroupManagersRecreateInstancesRequest{
+			Instances: instances,
+		}
+
+		op, err := config.clientComputeBeta.InstanceGroupManagers.RecreateInstances(project, zone, id, recreateInstances).Do()
+		if err != nil {
+			return fmt.Errorf("Error restarting instance group managers instances: %s", err)
+		}
+
+		// Wait for the operation to complete
+		err = computeSharedOperationWaitTime(config.clientCompute, op, project, managedInstanceCount*4, "Restarting InstanceGroupManagers instances")
+		if err != nil {
+			return err
+		}
+	}
+
+	if updateStrategy == "ROLLING_UPDATE" {
+		// UpdatePolicy is set for InstanceGroupManager on update only, because it is only relevant for `Patch` calls.
+		// Other tools(gcloud and UI) capable of executing the same `ROLLING UPDATE` call
+		// expect those values to be provided by user as part of the call
+		// or provide their own defaults without respecting what was previously set on UpdateManager.
+		// To follow the same logic, we provide policy values on relevant update change only.
+		manager := &computeBeta.InstanceGroupManager{
+			UpdatePolicy: rollingUpdatePolicy,
+			Versions:     versions,
+		}
+
+		op, err := config.clientComputeBeta.InstanceGroupManagers.Patch(project, zone, id, manager).Do()
+		if err != nil {
+			return fmt.Errorf("Error updating managed group instances: %s", err)
+		}
+
+		err = computeSharedOperationWait(config.clientCompute, op, project, "Updating managed group instances")
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func resourceComputeInstanceGroupManagerUpdate(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 
@@ -430,81 +558,6 @@ func resourceComputeInstanceGroupManagerUpdate(d *schema.ResourceData, meta inte
 		d.SetPartial("target_pools")
 	}
 
-	// If instance_template changes then update
-	if d.HasChange("instance_template") {
-		// Build the parameter
-		setInstanceTemplate := &computeBeta.InstanceGroupManagersSetInstanceTemplateRequest{
-			InstanceTemplate: d.Get("instance_template").(string),
-		}
-
-		op, err := config.clientComputeBeta.InstanceGroupManagers.SetInstanceTemplate(
-			project, zone, d.Id(), setInstanceTemplate).Do()
-
-		if err != nil {
-			return fmt.Errorf("Error updating InstanceGroupManager: %s", err)
-		}
-
-		// Wait for the operation to complete
-		err = computeSharedOperationWait(config.clientCompute, op, project, "Updating InstanceGroupManager")
-		if err != nil {
-			return err
-		}
-
-		if d.Get("update_strategy").(string) == "RESTART" {
-			managedInstances, err := config.clientComputeBeta.InstanceGroupManagers.ListManagedInstances(
-				project, zone, d.Id()).Do()
-			if err != nil {
-				return fmt.Errorf("Error getting instance group managers instances: %s", err)
-			}
-
-			managedInstanceCount := len(managedInstances.ManagedInstances)
-			instances := make([]string, managedInstanceCount)
-			for i, v := range managedInstances.ManagedInstances {
-				instances[i] = v.Instance
-			}
-
-			recreateInstances := &computeBeta.InstanceGroupManagersRecreateInstancesRequest{
-				Instances: instances,
-			}
-
-			op, err = config.clientComputeBeta.InstanceGroupManagers.RecreateInstances(
-				project, zone, d.Id(), recreateInstances).Do()
-			if err != nil {
-				return fmt.Errorf("Error restarting instance group managers instances: %s", err)
-			}
-
-			// Wait for the operation to complete
-			err = computeSharedOperationWaitTime(config.clientCompute, op, project, managedInstanceCount*4, "Restarting InstanceGroupManagers instances")
-			if err != nil {
-				return err
-			}
-		}
-
-		if d.Get("update_strategy").(string) == "ROLLING_UPDATE" {
-			// UpdatePolicy is set for InstanceGroupManager on update only, because it is only relevant for `Patch` calls.
-			// Other tools(gcloud and UI) capable of executing the same `ROLLING UPDATE` call
-			// expect those values to be provided by user as part of the call
-			// or provide their own defaults without respecting what was previously set on UpdateManager.
-			// To follow the same logic, we provide policy values on relevant update change only.
-			manager := &computeBeta.InstanceGroupManager{
-				UpdatePolicy: expandUpdatePolicy(d.Get("rolling_update_policy").([]interface{})),
-			}
-
-			op, err = config.clientComputeBeta.InstanceGroupManagers.Patch(
-				project, zone, d.Id(), manager).Do()
-			if err != nil {
-				return fmt.Errorf("Error updating managed group instances: %s", err)
-			}
-
-			err = computeSharedOperationWait(config.clientCompute, op, project, "Updating managed group instances")
-			if err != nil {
-				return err
-			}
-		}
-
-		d.SetPartial("instance_template")
-	}
-
 	// If named_port changes then update:
 	if d.HasChange("named_port") {
 
@@ -572,6 +625,44 @@ func resourceComputeInstanceGroupManagerUpdate(d *schema.ResourceData, meta inte
 		d.SetPartial("auto_healing_policies")
 	}
 
+	// If instance_template changes then update
+	if d.HasChange("instance_template") {
+		// Build the parameter
+		setInstanceTemplate := &computeBeta.InstanceGroupManagersSetInstanceTemplateRequest{
+			InstanceTemplate: d.Get("instance_template").(string),
+		}
+
+		op, err := config.clientComputeBeta.InstanceGroupManagers.SetInstanceTemplate(project, zone, d.Id(), setInstanceTemplate).Do()
+
+		if err != nil {
+			return fmt.Errorf("Error updating InstanceGroupManager: %s", err)
+		}
+
+		// Wait for the operation to complete
+		err = computeSharedOperationWait(config.clientCompute, op, project, "Updating InstanceGroupManager")
+		if err != nil {
+			return err
+		}
+
+		updateStrategy := d.Get("update_strategy").(string)
+		rollingUpdatePolicy := expandUpdatePolicy(d.Get("rolling_update_policy").([]interface{}))
+		err = performUpdate(config, d.Id(), updateStrategy, rollingUpdatePolicy, nil, project, zone)
+		d.SetPartial("instance_template")
+	}
+
+	// If version changes then update
+	if d.HasChange("version") {
+		updateStrategy := d.Get("update_strategy").(string)
+		rollingUpdatePolicy := expandUpdatePolicy(d.Get("rolling_update_policy").([]interface{}))
+		versions := expandVersions(d.Get("version").([]interface{}))
+		err = performUpdate(config, d.Id(), updateStrategy, rollingUpdatePolicy, versions, project, zone)
+		if err != nil {
+			return err
+		}
+
+		d.SetPartial("version")
+	}
+
 	d.Partial(false)
 
 	return resourceComputeInstanceGroupManagerRead(d, meta)
@@ -647,6 +738,37 @@ func expandAutoHealingPolicies(configured []interface{}) []*computeBeta.Instance
 	return autoHealingPolicies
 }
 
+func expandVersions(configured []interface{}) []*computeBeta.InstanceGroupManagerVersion {
+	versions := make([]*computeBeta.InstanceGroupManagerVersion, 0, len(configured))
+	for _, raw := range configured {
+		data := raw.(map[string]interface{})
+
+		version := computeBeta.InstanceGroupManagerVersion{
+			Name:             data["name"].(string),
+			InstanceTemplate: data["instance_template"].(string),
+			TargetSize:       expandFixedOrPercent(data["target_size"].([]interface{})),
+		}
+
+		versions = append(versions, &version)
+	}
+	return versions
+}
+
+func expandFixedOrPercent(configured []interface{}) *computeBeta.FixedOrPercent {
+	fixedOrPercent := &computeBeta.FixedOrPercent{}
+
+	for _, raw := range configured {
+		data := raw.(map[string]interface{})
+		if percent := data["percent"]; percent.(int) > 0 {
+			fixedOrPercent.Percent = int64(percent.(int))
+		} else {
+			fixedOrPercent.Fixed = int64(data["fixed"].(int))
+			fixedOrPercent.ForceSendFields = []string{"Fixed"}
+		}
+	}
+	return fixedOrPercent
+}
+
 func expandUpdatePolicy(configured []interface{}) *computeBeta.InstanceGroupManagerUpdatePolicy {
 	updatePolicy := &computeBeta.InstanceGroupManagerUpdatePolicy{}