diff --git a/mmv1/third_party/terraform/services/compute/resource_compute_instance_group_manager.go.tmpl b/mmv1/third_party/terraform/services/compute/resource_compute_instance_group_manager.go.tmpl index 5a4c92f240f0..c4c09cef58eb 100644 --- a/mmv1/third_party/terraform/services/compute/resource_compute_instance_group_manager.go.tmpl +++ b/mmv1/third_party/terraform/services/compute/resource_compute_instance_group_manager.go.tmpl @@ -4,6 +4,7 @@ import ( "context" "fmt" "log" + "strconv" "strings" "time" @@ -703,6 +704,98 @@ func getNamedPortsBeta(nps []interface{}) []*compute.NamedPort { return namedPorts } +func getNamedPortsBetaV2(nps []interface{}) []interface{} { + namedPorts := make([]interface{}, 0, len(nps)) + for _, v := range nps { + np := v.(map[string]interface{}) + namedPorts = append(namedPorts, map[string]interface{}{ + "name": np["name"].(string), + "port": int64(np["port"].(int)), + }) + } + + return namedPorts +} + +func stringFromMap(m map[string]interface{}, key string) string { + if m == nil { + return "" + } + if v, ok := m[key].(string); ok { + return v + } + return "" +} + +func mapFromInterface(v interface{}) map[string]interface{} { + if v == nil { + return nil + } + if m, ok := v.(map[string]interface{}); ok { + return m + } + return nil +} + +func sliceFromInterface(v interface{}) []interface{} { + if v == nil { + return nil + } + if s, ok := v.([]interface{}); ok { + return s + } + return nil +} + +func stringSliceFromInterface(v interface{}) []string { + raw := sliceFromInterface(v) + result := make([]string, 0, len(raw)) + for _, item := range raw { + if s, ok := item.(string); ok { + result = append(result, s) + } + } + return result +} + +func int64FromInterface(v interface{}) int64 { + switch value := v.(type) { + case int: + return int64(value) + case int64: + return value + case uint64: + return int64(value) + case float64: + return int64(value) + case string: + parsed, err := strconv.ParseInt(value, 10, 64) + if err == nil { + return parsed + } + parsedUint, err := strconv.ParseUint(value, 10, 64) + if err == nil { + return int64(parsedUint) + } + } + return 0 +} + +func boolFromInterface(v interface{}) bool { + if value, ok := v.(bool); ok { + return value + } + return false +} + +func mapStringInterfaceFromStringMap(input map[string]string) map[string]interface{} { + result := make(map[string]interface{}, len(input)) + for k, v := range input { + result[k] = v + } + return result +} + func resourceComputeInstanceGroupManagerCreate(d *schema.ResourceData, meta interface{}) error { config := meta.(*transport_tpg.Config) userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) @@ -715,42 +808,62 @@ func resourceComputeInstanceGroupManagerCreate(d *schema.ResourceData, meta inte return err } - zone, err := tpgresource.GetZone(d, config) - if err != nil { - return err + insertBody := map[string]interface{}{ + "name": d.Get("name").(string), + "description": d.Get("description").(string), + "baseInstanceName": d.Get("base_instance_name").(string), + "targetSize": int64(d.Get("target_size").(int)), + "listManagedInstancesResults": d.Get("list_managed_instances_results").(string), + "versions": expandVersionsV2(d.Get("version").([]interface{})), + "standbyPolicy": expandStandbyPolicyV2(d), + "updatePolicy": expandUpdatePolicyV2(d.Get("update_policy").([]interface{})), + "instanceLifecyclePolicy": expandInstanceLifecyclePolicyV2(d.Get("instance_lifecycle_policy").([]interface{})), + "statefulPolicy": expandStatefulPolicyV2(d), + "resourcePolicies": expandResourcePoliciesV2(d.Get("resource_policies").([]interface{})), } - // Build the parameter - manager := &compute.InstanceGroupManager{ - Name: d.Get("name").(string), - Description: d.Get("description").(string), - BaseInstanceName: d.Get("base_instance_name").(string), - TargetSize: int64(d.Get("target_size").(int)), - ListManagedInstancesResults: d.Get("list_managed_instances_results").(string), - NamedPorts: getNamedPortsBeta(d.Get("named_port").(*schema.Set).List()), - TargetPools: tpgresource.ConvertStringSet(d.Get("target_pools").(*schema.Set)), - AutoHealingPolicies: expandAutoHealingPolicies(d.Get("auto_healing_policies").([]interface{})), - Versions: expandVersions(d.Get("version").([]interface{})), - StandbyPolicy: expandStandbyPolicy(d), - TargetSuspendedSize: int64(d.Get("target_suspended_size").(int)), - TargetStoppedSize: int64(d.Get("target_stopped_size").(int)), - UpdatePolicy: expandUpdatePolicy(d.Get("update_policy").([]interface{})), - InstanceLifecyclePolicy: expandInstanceLifecyclePolicy(d.Get("instance_lifecycle_policy").([]interface{})), - AllInstancesConfig: expandAllInstancesConfig(nil, d.Get("all_instances_config").([]interface{})), - StatefulPolicy: expandStatefulPolicy(d), - ResourcePolicies: expandResourcePolicies(d.Get("resource_policies").([]interface{})), - TargetSizePolicy: expandTargetSizePolicy(d.Get("target_size_policy").([]interface{})), - {{- if ne $.TargetVersionName "ga" }} - Params: expandInstanceGroupManagerParams(d), - {{- end }} + if namedPorts := getNamedPortsBetaV2(d.Get("named_port").(*schema.Set).List()); len(namedPorts) > 0 { + insertBody["namedPorts"] = namedPorts + } + if targetPools := tpgresource.ConvertStringSet(d.Get("target_pools").(*schema.Set)); len(targetPools) > 0 { + insertBody["targetPools"] = targetPools + } + if targetSuspendedSize := d.Get("target_suspended_size").(int); targetSuspendedSize > 0 { + insertBody["targetSuspendedSize"] = int64(targetSuspendedSize) + } + if targetStoppedSize := d.Get("target_stopped_size").(int); targetStoppedSize > 0 { + insertBody["targetStoppedSize"] = int64(targetStoppedSize) + } + if autoHealingPolicies := expandAutoHealingPoliciesV2(d.Get("auto_healing_policies").([]interface{})); len(autoHealingPolicies) > 0 { + insertBody["autoHealingPolicies"] = autoHealingPolicies + } + if allInstancesConfig := expandAllInstancesConfigV2(nil, d.Get("all_instances_config").([]interface{})); allInstancesConfig != nil { + insertBody["allInstancesConfig"] = allInstancesConfig + } + if targetSizePolicy := expandTargetSizePolicyV2(d.Get("target_size_policy").([]interface{})); targetSizePolicy != nil { + insertBody["targetSizePolicy"] = targetSizePolicy + } + {{- if ne $.TargetVersionName "ga" }} + if params := expandInstanceGroupManagerParamsV2(d); params != nil { + insertBody["params"] = params + } + {{- end }} - // Force send TargetSize to allow a value of 0. - ForceSendFields: []string{"TargetSize"}, + url, err := tpgresource.ReplaceVars(d, config, "{{"{{"}}ComputeBasePath{{"}}"}}projects/{{"{{"}}project{{"}}"}}/zones/{{"{{"}}zone{{"}}"}}/instanceGroupManagers") + if err != nil { + return err } - log.Printf("[DEBUG] InstanceGroupManager insert request: %#v", manager) - op, err := config.NewComputeClient(userAgent).InstanceGroupManagers.Insert( - project, zone, manager).Do() + log.Printf("[DEBUG] InstanceGroupManager insert request: %#v", insertBody) + op, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ + Config: config, + Method: "POST", + Project: project, + RawURL: url, + UserAgent: userAgent, + Body: insertBody, + Timeout: d.Timeout(schema.TimeoutCreate), + }) if err != nil { return fmt.Errorf("Error creating InstanceGroupManager: %s", err) @@ -772,8 +885,9 @@ func resourceComputeInstanceGroupManagerCreate(d *schema.ResourceData, meta inte // by the upstream Terraform process exiting early such as a sigterm. select { case <-config.Context.Done(): - log.Printf("[DEBUG] Persisting %s so this operation can be resumed \n", op.Name) - if err := d.Set("operation", op.Name); err != nil { + opName, _ := op["name"].(string) + log.Printf("[DEBUG] Persisting %s so this operation can be resumed \n", opName) + if err := d.Set("operation", opName); err != nil { return fmt.Errorf("Error setting operation: %s", err) } return nil @@ -805,6 +919,19 @@ func flattenNamedPortsBeta(namedPorts []*compute.NamedPort) []map[string]interfa } +func flattenNamedPortsBetaV2(raw interface{}) []map[string]interface{} { + namedPorts := sliceFromInterface(raw) + result := make([]map[string]interface{}, 0, len(namedPorts)) + for _, namedPortRaw := range namedPorts { + namedPort := mapFromInterface(namedPortRaw) + result = append(result, map[string]interface{}{ + "name": stringFromMap(namedPort, "name"), + "port": int64FromInterface(namedPort["port"]), + }) + } + return result +} + func flattenVersions(versions []*compute.InstanceGroupManagerVersion) []map[string]interface{} { result := make([]map[string]interface{}, 0, len(versions)) for _, version := range versions { @@ -818,6 +945,20 @@ func flattenVersions(versions []*compute.InstanceGroupManagerVersion) []map[stri return result } +func flattenVersionsV2(raw interface{}) []map[string]interface{} { + versions := sliceFromInterface(raw) + result := make([]map[string]interface{}, 0, len(versions)) + for _, versionRaw := range versions { + version := mapFromInterface(versionRaw) + result = append(result, map[string]interface{}{ + "name": stringFromMap(version, "name"), + "instance_template": tpgresource.ConvertSelfLinkToV1(stringFromMap(version, "instanceTemplate")), + "target_size": flattenFixedOrPercentV2(version["targetSize"]), + }) + } + return result +} + func flattenFixedOrPercent(fixedOrPercent *compute.FixedOrPercent) []map[string]interface{} { result := make(map[string]interface{}) if value := fixedOrPercent.Percent; value > 0 { @@ -830,6 +971,19 @@ func flattenFixedOrPercent(fixedOrPercent *compute.FixedOrPercent) []map[string] return []map[string]interface{}{result} } +func flattenFixedOrPercentV2(raw interface{}) []map[string]interface{} { + fixedOrPercent := mapFromInterface(raw) + result := make(map[string]interface{}) + if value := int64FromInterface(fixedOrPercent["percent"]); value > 0 { + result["percent"] = value + } else if value := int64FromInterface(fixedOrPercent["fixed"]); value > 0 { + result["fixed"] = value + } else { + return []map[string]interface{}{} + } + return []map[string]interface{}{result} +} + func getManager(d *schema.ResourceData, meta interface{}) (*compute.InstanceGroupManager, error) { config := meta.(*transport_tpg.Config) @@ -851,6 +1005,47 @@ func getManager(d *schema.ResourceData, meta interface{}) (*compute.InstanceGrou return nil, transport_tpg.HandleNotFoundError(err, d, fmt.Sprintf("Instance Group Manager %q", name)) } + if manager == nil { + log.Printf("[WARN] Removing Instance Group Manager %q because it's gone", d.Get("name").(string)) + + // The resource doesn't exist anymore + d.SetId("") + return nil, nil + } + return manager, nil +} + +func readInstanceGroupManagerResponse(d *schema.ResourceData, meta interface{}) (map[string]interface{}, error) { + config := meta.(*transport_tpg.Config) + + project, err := tpgresource.GetProject(d, config) + if err != nil { + return nil, err + } + + userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) + if err != nil { + return nil, err + } + + name := d.Get("name").(string) + + url, err := tpgresource.ReplaceVars(d, config, "{{"{{"}}ComputeBasePath{{"}}"}}projects/{{"{{"}}project{{"}}"}}/zones/{{"{{"}}zone{{"}}"}}/instanceGroupManagers/{{"{{"}}name{{"}}"}}") + if err != nil { + return nil, err + } + + manager, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ + Config: config, + Method: "GET", + Project: project, + RawURL: url, + UserAgent: userAgent, + }) + if err != nil { + return nil, transport_tpg.HandleNotFoundError(err, d, fmt.Sprintf("Instance Group Manager %q", name)) + } + if manager == nil { log.Printf("[WARN] Removing Instance Group Manager %q because it's gone", d.Get("name").(string)) @@ -878,9 +1073,9 @@ func resourceComputeInstanceGroupManagerRead(d *schema.ResourceData, meta interf if operation != "" { log.Printf("[DEBUG] in progress operation detected at %v, attempting to resume", operation) zone, _ := tpgresource.GetZone(d, config) - op := &compute.Operation{ - Name: operation, - Zone: zone, + op := map[string]interface{}{ + "name": operation, + "zone": zone, } if err := d.Set("operation", ""); err != nil { return fmt.Errorf("Error unsetting operation: %s", err) @@ -894,7 +1089,7 @@ func resourceComputeInstanceGroupManagerRead(d *schema.ResourceData, meta interf } } - manager, err := getManager(d, meta) + manager, err := readInstanceGroupManagerResponse(d, meta) if err != nil { return err } @@ -904,93 +1099,93 @@ func resourceComputeInstanceGroupManagerRead(d *schema.ResourceData, meta interf return nil } - if err := d.Set("base_instance_name", manager.BaseInstanceName); err != nil { + if err := d.Set("base_instance_name", stringFromMap(manager, "baseInstanceName")); err != nil { return fmt.Errorf("Error setting base_instance_name: %s", err) } - if err := d.Set("name", manager.Name); err != nil { + if err := d.Set("name", stringFromMap(manager, "name")); err != nil { return fmt.Errorf("Error setting name: %s", err) } - if err := d.Set("zone", tpgresource.GetResourceNameFromSelfLink(manager.Zone)); err != nil { + if err := d.Set("zone", tpgresource.GetResourceNameFromSelfLink(stringFromMap(manager, "zone"))); err != nil { return fmt.Errorf("Error setting zone: %s", err) } - if err := d.Set("creation_timestamp", manager.CreationTimestamp); err != nil { + if err := d.Set("creation_timestamp", stringFromMap(manager, "creationTimestamp")); err != nil { return fmt.Errorf("Error reading creation_timestamp: %s", err) } - if err := d.Set("description", manager.Description); err != nil { + if err := d.Set("description", stringFromMap(manager, "description")); err != nil { return fmt.Errorf("Error setting description: %s", err) } - if err := d.Set("instance_group_manager_id", manager.Id); err != nil { + if err := d.Set("instance_group_manager_id", int64FromInterface(manager["id"])); err != nil { return fmt.Errorf("Error setting description: %s", err) } - + if err := d.Set("project", project); err != nil { return fmt.Errorf("Error setting project: %s", err) } - if err := d.Set("target_size", manager.TargetSize); err != nil { + if err := d.Set("target_size", int64FromInterface(manager["targetSize"])); err != nil { return fmt.Errorf("Error setting target_size: %s", err) } - if err := d.Set("list_managed_instances_results", manager.ListManagedInstancesResults); err != nil { + if err := d.Set("list_managed_instances_results", stringFromMap(manager, "listManagedInstancesResults")); err != nil { return fmt.Errorf("Error setting list_managed_instances_results: %s", err) } - if err = d.Set("target_pools", tpgresource.MapStringArr(manager.TargetPools, tpgresource.ConvertSelfLinkToV1)); err != nil { + if err = d.Set("target_pools", tpgresource.MapStringArr(stringSliceFromInterface(manager["targetPools"]), tpgresource.ConvertSelfLinkToV1)); err != nil { return fmt.Errorf("Error setting target_pools in state: %s", err.Error()) } - if err = d.Set("named_port", flattenNamedPortsBeta(manager.NamedPorts)); err != nil { + if err = d.Set("named_port", flattenNamedPortsBetaV2(manager["namedPorts"])); err != nil { return fmt.Errorf("Error setting named_port in state: %s", err.Error()) } - if err = d.Set("stateful_disk", flattenStatefulPolicy(manager.StatefulPolicy)); err != nil { + if err = d.Set("stateful_disk", flattenStatefulPolicyV2(manager["statefulPolicy"])); err != nil { return fmt.Errorf("Error setting stateful_disk in state: %s", err.Error()) } - if err = d.Set("stateful_internal_ip", flattenStatefulPolicyStatefulInternalIps(d, manager.StatefulPolicy)); err != nil { + if err = d.Set("stateful_internal_ip", flattenStatefulPolicyStatefulInternalIpsV2(d, manager["statefulPolicy"])); err != nil { return fmt.Errorf("Error setting stateful_internal_ip in state: %s", err.Error()) } - if err = d.Set("stateful_external_ip", flattenStatefulPolicyStatefulExternalIps(d, manager.StatefulPolicy)); err != nil { + if err = d.Set("stateful_external_ip", flattenStatefulPolicyStatefulExternalIpsV2(d, manager["statefulPolicy"])); err != nil { return fmt.Errorf("Error setting stateful_external_ip in state: %s", err.Error()) } - if err := d.Set("fingerprint", manager.Fingerprint); err != nil { + if err := d.Set("fingerprint", stringFromMap(manager, "fingerprint")); err != nil { return fmt.Errorf("Error setting fingerprint: %s", err) } - if err := d.Set("instance_group", tpgresource.ConvertSelfLinkToV1(manager.InstanceGroup)); err != nil { + if err := d.Set("instance_group", tpgresource.ConvertSelfLinkToV1(stringFromMap(manager, "instanceGroup"))); err != nil { return fmt.Errorf("Error setting instance_group: %s", err) } - if err := d.Set("self_link", tpgresource.ConvertSelfLinkToV1(manager.SelfLink)); err != nil { + if err := d.Set("self_link", tpgresource.ConvertSelfLinkToV1(stringFromMap(manager, "selfLink"))); err != nil { return fmt.Errorf("Error setting self_link: %s", err) } - if err = d.Set("auto_healing_policies", flattenAutoHealingPolicies(manager.AutoHealingPolicies)); err != nil { + if err = d.Set("auto_healing_policies", flattenAutoHealingPoliciesV2(manager["autoHealingPolicies"])); err != nil { return fmt.Errorf("Error setting auto_healing_policies in state: %s", err.Error()) } - if err := d.Set("version", flattenVersions(manager.Versions)); err != nil { + if err := d.Set("version", flattenVersionsV2(manager["versions"])); err != nil { return err } - if err = d.Set("standby_policy", flattenStandbyPolicy(manager.StandbyPolicy)); err != nil { + if err = d.Set("standby_policy", flattenStandbyPolicyV2(manager["standbyPolicy"])); err != nil { return fmt.Errorf("Error setting standby_policy in state: %s", err.Error()) } - if err := d.Set("target_suspended_size", manager.TargetSuspendedSize); err != nil { + if err := d.Set("target_suspended_size", int64FromInterface(manager["targetSuspendedSize"])); err != nil { return fmt.Errorf("Error setting target_suspended_size: %s", err) } - if err := d.Set("target_stopped_size", manager.TargetStoppedSize); err != nil { + if err := d.Set("target_stopped_size", int64FromInterface(manager["targetStoppedSize"])); err != nil { return fmt.Errorf("Error setting target_stopped_size: %s", err) } - if err = d.Set("update_policy", flattenUpdatePolicy(manager.UpdatePolicy)); err != nil { + if err = d.Set("update_policy", flattenUpdatePolicyV2(manager["updatePolicy"])); err != nil { return fmt.Errorf("Error setting update_policy in state: %s", err.Error()) } - if err = d.Set("instance_lifecycle_policy", flattenInstanceLifecyclePolicy(manager.InstanceLifecyclePolicy)); err != nil { + if err = d.Set("instance_lifecycle_policy", flattenInstanceLifecyclePolicyV2(manager["instanceLifecyclePolicy"])); err != nil { return fmt.Errorf("Error setting instance lifecycle policy in state: %s", err.Error()) } - if manager.AllInstancesConfig != nil { - if err = d.Set("all_instances_config", flattenAllInstancesConfig(manager.AllInstancesConfig)); err != nil { + if manager["allInstancesConfig"] != nil { + if err = d.Set("all_instances_config", flattenAllInstancesConfigV2(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 { + if err = d.Set("status", flattenStatusV2(manager["status"])); err != nil { return fmt.Errorf("Error setting status in state: %s", err.Error()) } - if err = d.Set("resource_policies", flattenResourcePolicies(manager.ResourcePolicies)); err != nil { + if err = d.Set("resource_policies", flattenResourcePoliciesV2(manager["resourcePolicies"])); err != nil { return fmt.Errorf("Error setting resource_policies in state: %s", err.Error()) } - if err = d.Set("target_size_policy", flattenTargetSizePolicy(manager.TargetSizePolicy)); err != nil { + if err = d.Set("target_size_policy", flattenTargetSizePolicyV2(manager["targetSizePolicy"])); err != nil { return fmt.Errorf("Error setting target_size_policy in state: %s", err.Error()) } @@ -1259,6 +1454,18 @@ func expandAutoHealingPolicies(configured []interface{}) []*compute.InstanceGrou return autoHealingPolicies } +func expandAutoHealingPoliciesV2(configured []interface{}) []interface{} { + autoHealingPolicies := make([]interface{}, 0, len(configured)) + for _, raw := range configured { + data := raw.(map[string]interface{}) + autoHealingPolicies = append(autoHealingPolicies, map[string]interface{}{ + "healthCheck": data["health_check"].(string), + "initialDelaySec": int64(data["initial_delay_sec"].(int)), + }) + } + return autoHealingPolicies +} + func expandStatefulPolicy(d *schema.ResourceData) *compute.StatefulPolicy { preservedState := &compute.StatefulPolicyPreservedState{} @@ -1326,6 +1533,51 @@ func expandStatefulPolicy(d *schema.ResourceData) *compute.StatefulPolicy { return statefulPolicy } +func expandStatefulPolicyV2(d *schema.ResourceData) map[string]interface{} { + preservedState := map[string]interface{}{} + + if d.HasChange("stateful_disk") { + oldDisks, newDisks := d.GetChange("stateful_disk") + disks := expandStatefulDisksV2(newDisks.(*schema.Set).List()) + for _, raw := range oldDisks.(*schema.Set).List() { + data := raw.(map[string]interface{}) + deviceName := data["device_name"].(string) + if _, exist := disks[deviceName]; !exist { + disks[deviceName] = nil + } + } + preservedState["disks"] = disks + } + + if d.HasChange("stateful_internal_ip") { + oldInternalIps, newInternalIps := d.GetChange("stateful_internal_ip") + internalIPs := expandStatefulIpsV2(newInternalIps.([]interface{})) + for _, raw := range oldInternalIps.([]interface{}) { + data := raw.(map[string]interface{}) + interfaceName := data["interface_name"].(string) + if _, exist := internalIPs[interfaceName]; !exist { + internalIPs[interfaceName] = nil + } + } + preservedState["internalIPs"] = internalIPs + } + + if d.HasChange("stateful_external_ip") { + oldExternalIps, newExternalIps := d.GetChange("stateful_external_ip") + externalIPs := expandStatefulIpsV2(newExternalIps.([]interface{})) + for _, raw := range oldExternalIps.([]interface{}) { + data := raw.(map[string]interface{}) + interfaceName := data["interface_name"].(string) + if _, exist := externalIPs[interfaceName]; !exist { + externalIPs[interfaceName] = nil + } + } + preservedState["externalIPs"] = externalIPs + } + + return map[string]interface{}{"preservedState": preservedState} +} + func expandStatefulDisks(statefulDisk []interface{}) map[string]compute.StatefulPolicyPreservedStateDiskDevice { statefulDisksMap := make(map[string]compute.StatefulPolicyPreservedStateDiskDevice) @@ -1339,6 +1591,17 @@ func expandStatefulDisks(statefulDisk []interface{}) map[string]compute.Stateful return statefulDisksMap } +func expandStatefulDisksV2(statefulDisk []interface{}) map[string]interface{} { + statefulDisksMap := make(map[string]interface{}) + for _, raw := range statefulDisk { + data := raw.(map[string]interface{}) + statefulDisksMap[data["device_name"].(string)] = map[string]interface{}{ + "autoDelete": data["delete_rule"].(string), + } + } + return statefulDisksMap +} + func expandStatefulIps(statefulIP []interface{}) map[string]compute.StatefulPolicyPreservedStateNetworkIp { statefulIpsMap := make(map[string]compute.StatefulPolicyPreservedStateNetworkIp) @@ -1352,6 +1615,17 @@ func expandStatefulIps(statefulIP []interface{}) map[string]compute.StatefulPoli return statefulIpsMap } +func expandStatefulIpsV2(statefulIP []interface{}) map[string]interface{} { + statefulIpsMap := make(map[string]interface{}) + for _, raw := range statefulIP { + data := raw.(map[string]interface{}) + statefulIpsMap[data["interface_name"].(string)] = map[string]interface{}{ + "autoDelete": data["delete_rule"].(string), + } + } + return statefulIpsMap +} + func expandVersions(configured []interface{}) []*compute.InstanceGroupManagerVersion { versions := make([]*compute.InstanceGroupManagerVersion, 0, len(configured)) for _, raw := range configured { @@ -1368,6 +1642,19 @@ func expandVersions(configured []interface{}) []*compute.InstanceGroupManagerVer return versions } +func expandVersionsV2(configured []interface{}) []interface{} { + versions := make([]interface{}, 0, len(configured)) + for _, raw := range configured { + data := raw.(map[string]interface{}) + versions = append(versions, map[string]interface{}{ + "name": data["name"].(string), + "instanceTemplate": ConvertToUniqueIdWhenPresent(data["instance_template"].(string)), + "targetSize": expandFixedOrPercentV2(data["target_size"].([]interface{})), + }) + } + return versions +} + func expandTargetSizePolicy(configured []interface{}) *compute.InstanceGroupManagerTargetSizePolicy { if len(configured) == 0 || configured[0] == nil { return nil @@ -1378,6 +1665,16 @@ func expandTargetSizePolicy(configured []interface{}) *compute.InstanceGroupMana } } +func expandTargetSizePolicyV2(configured []interface{}) map[string]interface{} { + if len(configured) == 0 || configured[0] == nil { + return nil + } + data := configured[0].(map[string]interface{}) + return map[string]interface{}{ + "mode": data["mode"].(string), + } +} + func expandResourcePolicies(configured []interface{}) *compute.InstanceGroupManagerResourcePolicies { resourcePolicies := &compute.InstanceGroupManagerResourcePolicies{} @@ -1392,6 +1689,16 @@ func expandResourcePolicies(configured []interface{}) *compute.InstanceGroupMana return resourcePolicies } +func expandResourcePoliciesV2(configured []interface{}) map[string]interface{} { + if len(configured) == 0 { + return map[string]interface{}{"workloadPolicy": nil} + } + data := configured[0].(map[string]interface{}) + return map[string]interface{}{ + "workloadPolicy": data["workload_policy"].(string), + } +} + func expandFixedOrPercent(configured []interface{}) *compute.FixedOrPercent { fixedOrPercent := &compute.FixedOrPercent{} @@ -1409,6 +1716,24 @@ func expandFixedOrPercent(configured []interface{}) *compute.FixedOrPercent { return fixedOrPercent } +func expandFixedOrPercentV2(configured []interface{}) map[string]interface{} { + fixedOrPercent := map[string]interface{}{} + for _, raw := range configured { + if raw == nil { + continue + } + data := raw.(map[string]interface{}) + if percent := data["percent"]; percent.(int) > 0 { + fixedOrPercent["percent"] = int64(percent.(int)) + fixedOrPercent["fixed"] = nil + } else { + fixedOrPercent["fixed"] = int64(data["fixed"].(int)) + fixedOrPercent["percent"] = nil + } + } + return fixedOrPercent +} + func expandInstanceLifecyclePolicy(configured []interface{}) *compute.InstanceGroupManagerInstanceLifecyclePolicy { instanceLifecyclePolicy := &compute.InstanceGroupManagerInstanceLifecyclePolicy{} @@ -1428,6 +1753,24 @@ func expandInstanceLifecyclePolicy(configured []interface{}) *compute.InstanceGr return instanceLifecyclePolicy } +func expandInstanceLifecyclePolicyV2(configured []interface{}) map[string]interface{} { + instanceLifecyclePolicy := map[string]interface{}{} + for _, raw := range configured { + data := raw.(map[string]interface{}) + instanceLifecyclePolicy["forceUpdateOnRepair"] = data["force_update_on_repair"].(string) + instanceLifecyclePolicy["defaultActionOnFailure"] = data["default_action_on_failure"].(string) + + {{ if ne $.TargetVersionName `ga` -}} + instanceLifecyclePolicy["onFailedHealthCheck"] = data["on_failed_health_check"].(string) + {{- end }} + + {{- if ne $.TargetVersionName `ga` }} + instanceLifecyclePolicy["onRepair"] = expandOnRepairV2(data["on_repair"].([]any)) + {{- end }} + } + return instanceLifecyclePolicy +} + {{ if ne $.TargetVersionName `ga` -}} func expandOnRepair(configured []any) *compute.InstanceGroupManagerInstanceLifecyclePolicyOnRepair { onRepair := &compute.InstanceGroupManagerInstanceLifecyclePolicyOnRepair{} @@ -1437,6 +1780,15 @@ func expandOnRepair(configured []any) *compute.InstanceGroupManagerInstanceLifec } return onRepair } + +func expandOnRepairV2(configured []any) map[string]interface{} { + onRepair := map[string]interface{}{} + for _, raw := range configured { + data := raw.(map[string]any) + onRepair["allowChangingZone"] = data["allow_changing_zone"].(string) + } + return onRepair +} {{- end }} func expandStandbyPolicy(d *schema.ResourceData) *compute.InstanceGroupManagerStandbyPolicy { @@ -1450,9 +1802,18 @@ func expandStandbyPolicy(d *schema.ResourceData) *compute.InstanceGroupManagerSt return standbyPolicy } +func expandStandbyPolicyV2(d *schema.ResourceData) map[string]interface{} { + standbyPolicy := map[string]interface{}{} + for _, sp := range d.Get("standby_policy").([]any) { + spData := sp.(map[string]any) + standbyPolicy["initialDelaySec"] = int64(spData["initial_delay_sec"].(int)) + standbyPolicy["mode"] = spData["mode"].(string) + } + return standbyPolicy +} + func expandUpdatePolicy(configured []interface{}) *compute.InstanceGroupManagerUpdatePolicy { updatePolicy := &compute.InstanceGroupManagerUpdatePolicy{} - for _, raw := range configured { data := raw.(map[string]interface{}) @@ -1503,6 +1864,50 @@ func expandUpdatePolicy(configured []interface{}) *compute.InstanceGroupManagerU return updatePolicy } +func expandUpdatePolicyV2(configured []interface{}) map[string]interface{} { + updatePolicy := map[string]interface{}{} + for _, raw := range configured { + data := raw.(map[string]interface{}) + + updatePolicy["minimalAction"] = data["minimal_action"].(string) + if mostDisruptiveAllowedAction := data["most_disruptive_allowed_action"].(string); mostDisruptiveAllowedAction != "" { + updatePolicy["mostDisruptiveAllowedAction"] = mostDisruptiveAllowedAction + } else { + updatePolicy["mostDisruptiveAllowedAction"] = nil + } + updatePolicy["type"] = data["type"].(string) + updatePolicy["replacementMethod"] = data["replacement_method"].(string) +{{- if ne $.TargetVersionName "ga" }} + updatePolicy["minReadySec"] = int64(data["min_ready_sec"].(int)) +{{- end }} + + if v := data["max_surge_percent"]; v.(int) > 0 { + updatePolicy["maxSurge"] = map[string]interface{}{ + "percent": int64(v.(int)), + "fixed": nil, + } + } else { + updatePolicy["maxSurge"] = map[string]interface{}{ + "fixed": int64(data["max_surge_fixed"].(int)), + "percent": nil, + } + } + + if v := data["max_unavailable_percent"]; v.(int) > 0 { + updatePolicy["maxUnavailable"] = map[string]interface{}{ + "percent": int64(v.(int)), + "fixed": nil, + } + } else { + updatePolicy["maxUnavailable"] = map[string]interface{}{ + "fixed": int64(data["max_unavailable_fixed"].(int)), + "percent": nil, + } + } + } + return updatePolicy +} + {{ if ne $.TargetVersionName `ga` -}} func expandInstanceGroupManagerParams(d *schema.ResourceData) *compute.InstanceGroupManagerParams { params := &compute.InstanceGroupManagerParams{} @@ -1513,6 +1918,16 @@ func expandInstanceGroupManagerParams(d *schema.ResourceData) *compute.InstanceG return params } + +func expandInstanceGroupManagerParamsV2(d *schema.ResourceData) map[string]interface{} { + if _, ok := d.GetOk("params.0.resource_manager_tags"); ok { + return map[string]interface{}{ + "resourceManagerTags": mapStringInterfaceFromStringMap(tpgresource.ExpandStringMap(d, "params.0.resource_manager_tags")), + } + } + + return map[string]interface{}{} +} {{- end }} func flattenAutoHealingPolicies(autoHealingPolicies []*compute.InstanceGroupManagerAutoHealingPolicy) []map[string]interface{} { @@ -1528,6 +1943,19 @@ func flattenAutoHealingPolicies(autoHealingPolicies []*compute.InstanceGroupMana return autoHealingPoliciesSchema } +func flattenAutoHealingPoliciesV2(raw interface{}) []map[string]interface{} { + autoHealingPolicies := sliceFromInterface(raw) + result := make([]map[string]interface{}, 0, len(autoHealingPolicies)) + for _, autoHealingPolicyRaw := range autoHealingPolicies { + autoHealingPolicy := mapFromInterface(autoHealingPolicyRaw) + result = append(result, map[string]interface{}{ + "health_check": stringFromMap(autoHealingPolicy, "healthCheck"), + "initial_delay_sec": int64FromInterface(autoHealingPolicy["initialDelaySec"]), + }) + } + return result +} + func flattenStatefulPolicy(statefulPolicy *compute.StatefulPolicy) []map[string]interface{} { if statefulPolicy == nil || statefulPolicy.PreservedState == nil || statefulPolicy.PreservedState.Disks == nil { return make([]map[string]interface{}, 0, 0) @@ -1544,6 +1972,24 @@ func flattenStatefulPolicy(statefulPolicy *compute.StatefulPolicy) []map[string] return result } +func flattenStatefulPolicyV2(raw interface{}) []map[string]interface{} { + statefulPolicy := mapFromInterface(raw) + preservedState := mapFromInterface(statefulPolicy["preservedState"]) + disks := mapFromInterface(preservedState["disks"]) + if disks == nil { + return make([]map[string]interface{}, 0, 0) + } + result := make([]map[string]interface{}, 0, len(disks)) + for deviceName, diskRaw := range disks { + disk := mapFromInterface(diskRaw) + result = append(result, map[string]interface{}{ + "device_name": deviceName, + "delete_rule": stringFromMap(disk, "autoDelete"), + }) + } + return result +} + func flattenStatefulPolicyStatefulInternalIps(d *schema.ResourceData, statefulPolicy *compute.StatefulPolicy) []map[string]interface{} { if statefulPolicy == nil || statefulPolicy.PreservedState == nil || statefulPolicy.PreservedState.InternalIPs == nil { return make([]map[string]interface{}, 0, 0) @@ -1552,6 +1998,12 @@ func flattenStatefulPolicyStatefulInternalIps(d *schema.ResourceData, statefulPo return flattenStatefulPolicyStatefulIps(d, "stateful_internal_ip", statefulPolicy.PreservedState.InternalIPs) } +func flattenStatefulPolicyStatefulInternalIpsV2(d *schema.ResourceData, raw interface{}) []map[string]interface{} { + statefulPolicy := mapFromInterface(raw) + preservedState := mapFromInterface(statefulPolicy["preservedState"]) + return flattenStatefulPolicyStatefulIpsV2(d, "stateful_internal_ip", mapFromInterface(preservedState["internalIPs"])) +} + func flattenStatefulPolicyStatefulExternalIps(d *schema.ResourceData, statefulPolicy *compute.StatefulPolicy) []map[string]interface{} { if statefulPolicy == nil || statefulPolicy.PreservedState == nil || statefulPolicy.PreservedState.ExternalIPs == nil { return make([]map[string]interface{}, 0) @@ -1560,6 +2012,12 @@ func flattenStatefulPolicyStatefulExternalIps(d *schema.ResourceData, statefulPo return flattenStatefulPolicyStatefulIps(d, "stateful_external_ip", statefulPolicy.PreservedState.ExternalIPs) } +func flattenStatefulPolicyStatefulExternalIpsV2(d *schema.ResourceData, raw interface{}) []map[string]interface{} { + statefulPolicy := mapFromInterface(raw) + preservedState := mapFromInterface(statefulPolicy["preservedState"]) + return flattenStatefulPolicyStatefulIpsV2(d, "stateful_external_ip", mapFromInterface(preservedState["externalIPs"])) +} + func flattenStatefulPolicyStatefulIps(d *schema.ResourceData, ipfieldName string, ips map[string]compute.StatefulPolicyPreservedStateNetworkIp) []map[string]interface{} { // statefulPolicy.PreservedState.ExternalIPs and statefulPolicy.PreservedState.InternalIPs are affected by API-side reordering // of external/internal IPs, where ordering is done by the interface_name value. @@ -1586,6 +2044,31 @@ func flattenStatefulPolicyStatefulIps(d *schema.ResourceData, ipfieldName string return sorted } +func flattenStatefulPolicyStatefulIpsV2(d *schema.ResourceData, ipfieldName string, ips map[string]interface{}) []map[string]interface{} { + if ips == nil { + return make([]map[string]interface{}, 0) + } + + configData := []map[string]interface{}{} + for _, item := range d.Get(ipfieldName).([]interface{}) { + configData = append(configData, item.(map[string]interface{})) + } + apiData := []map[string]interface{}{} + for interfaceName, ipRaw := range ips { + ip := mapFromInterface(ipRaw) + apiData = append(apiData, map[string]interface{}{ + "interface_name": interfaceName, + "delete_rule": stringFromMap(ip, "autoDelete"), + }) + } + sorted, err := tpgresource.SortMapsByConfigOrder(configData, apiData, "interface_name") + if err != nil { + log.Printf("[ERROR] Could not sort API response for %s: %s", ipfieldName, err) + return apiData + } + return sorted +} + func flattenStandbyPolicy(standbyPolicy *compute.InstanceGroupManagerStandbyPolicy) []map[string]any{ results := []map[string]any{} if standbyPolicy != nil { @@ -1597,6 +2080,18 @@ func flattenStandbyPolicy(standbyPolicy *compute.InstanceGroupManagerStandbyPoli return results } +func flattenStandbyPolicyV2(raw interface{}) []map[string]any { + standbyPolicy := mapFromInterface(raw) + results := []map[string]any{} + if standbyPolicy != nil { + results = append(results, map[string]any{ + "initial_delay_sec": int64FromInterface(standbyPolicy["initialDelaySec"]), + "mode": stringFromMap(standbyPolicy, "mode"), + }) + } + return results +} + func flattenUpdatePolicy(updatePolicy *compute.InstanceGroupManagerUpdatePolicy) []map[string]interface{} { results := []map[string]interface{}{} if updatePolicy != nil { @@ -1627,6 +2122,39 @@ func flattenUpdatePolicy(updatePolicy *compute.InstanceGroupManagerUpdatePolicy) return results } +func flattenUpdatePolicyV2(raw interface{}) []map[string]interface{} { + updatePolicy := mapFromInterface(raw) + results := []map[string]interface{}{} + if updatePolicy != nil { + up := map[string]interface{}{} + maxSurge := mapFromInterface(updatePolicy["maxSurge"]) + if maxSurge != nil { + up["max_surge_fixed"] = int64FromInterface(maxSurge["fixed"]) + up["max_surge_percent"] = int64FromInterface(maxSurge["percent"]) + } else { + up["max_surge_fixed"] = 0 + up["max_surge_percent"] = 0 + } + maxUnavailable := mapFromInterface(updatePolicy["maxUnavailable"]) + if maxUnavailable != nil { + up["max_unavailable_fixed"] = int64FromInterface(maxUnavailable["fixed"]) + up["max_unavailable_percent"] = int64FromInterface(maxUnavailable["percent"]) + } else { + up["max_unavailable_fixed"] = 0 + up["max_unavailable_percent"] = 0 + } +{{- if ne $.TargetVersionName "ga" }} + up["min_ready_sec"] = int64FromInterface(updatePolicy["minReadySec"]) +{{- end }} + up["minimal_action"] = stringFromMap(updatePolicy, "minimalAction") + up["most_disruptive_allowed_action"] = stringFromMap(updatePolicy, "mostDisruptiveAllowedAction") + up["type"] = stringFromMap(updatePolicy, "type") + up["replacement_method"] = stringFromMap(updatePolicy, "replacementMethod") + results = append(results, up) + } + return results +} + func flattenInstanceLifecyclePolicy(instanceLifecyclePolicy *compute.InstanceGroupManagerInstanceLifecyclePolicy) []map[string]interface{} { results := []map[string]interface{}{} if instanceLifecyclePolicy != nil { @@ -1646,6 +2174,26 @@ func flattenInstanceLifecyclePolicy(instanceLifecyclePolicy *compute.InstanceGro return results } +func flattenInstanceLifecyclePolicyV2(raw interface{}) []map[string]interface{} { + instanceLifecyclePolicy := mapFromInterface(raw) + results := []map[string]interface{}{} + if instanceLifecyclePolicy != nil { + ilp := map[string]interface{}{} + ilp["force_update_on_repair"] = stringFromMap(instanceLifecyclePolicy, "forceUpdateOnRepair") + ilp["default_action_on_failure"] = stringFromMap(instanceLifecyclePolicy, "defaultActionOnFailure") + + {{ if ne $.TargetVersionName `ga` -}} + ilp["on_failed_health_check"] = stringFromMap(instanceLifecyclePolicy, "onFailedHealthCheck") + {{- end }} + + {{ if ne $.TargetVersionName `ga` -}} + ilp["on_repair"] = flattenOnRepairV2(instanceLifecyclePolicy["onRepair"]) + {{- end }} + results = append(results, ilp) + } + return results +} + {{ if ne $.TargetVersionName `ga` -}} func flattenOnRepair(onRepair *compute.InstanceGroupManagerInstanceLifecyclePolicyOnRepair) []map[string]any { results := []map[string]any{} @@ -1656,6 +2204,17 @@ func flattenOnRepair(onRepair *compute.InstanceGroupManagerInstanceLifecyclePoli } return results } + +func flattenOnRepairV2(raw interface{}) []map[string]any { + onRepair := mapFromInterface(raw) + results := []map[string]any{} + if onRepair != nil { + results = append(results, map[string]any{ + "allow_changing_zone": stringFromMap(onRepair, "allowChangingZone"), + }) + } + return results +} {{- end }} func expandAllInstancesConfig(old []interface{}, new []interface{}) *compute.InstanceGroupManagerAllInstancesConfig { @@ -1701,6 +2260,73 @@ func expandAllInstancesConfig(old []interface{}, new []interface{}) *compute.Ins } } +func expandAllInstancesConfigV2(old []interface{}, new []interface{}) map[string]interface{} { + var properties map[string]interface{} + for _, raw := range new { + properties = map[string]interface{}{} + if raw != nil { + data := raw.(map[string]interface{}) + metadata := map[string]interface{}{} + for k, v := range data["metadata"].(map[string]interface{}) { + metadata[k] = v + } + if len(metadata) == 0 { + properties["metadata"] = nil + } else { + properties["metadata"] = metadata + } + + labels := map[string]interface{}{} + for k, v := range data["labels"].(map[string]interface{}) { + labels[k] = v + } + if len(labels) == 0 { + properties["labels"] = nil + } else { + properties["labels"] = labels + } + } + } + + if properties != nil { + metadata := mapFromInterface(properties["metadata"]) + labels := mapFromInterface(properties["labels"]) + for _, raw := range old { + if raw != nil { + data := raw.(map[string]interface{}) + for k := range data["metadata"].(map[string]interface{}) { + if _, exist := metadata[k]; !exist { + if metadata == nil { + metadata = map[string]interface{}{} + } + metadata[k] = nil + } + } + for k := range data["labels"].(map[string]interface{}) { + if _, exist := labels[k]; !exist { + if labels == nil { + labels = map[string]interface{}{} + } + labels[k] = nil + } + } + } + } + if metadata != nil { + properties["metadata"] = metadata + } + if labels != nil { + properties["labels"] = labels + } + } + if properties != nil { + return map[string]interface{}{ + "properties": properties, + } + } + return nil +} + func flattenAllInstancesConfig(allInstancesConfig *compute.InstanceGroupManagerAllInstancesConfig) []map[string]interface{} { results := []map[string]interface{}{} props := map[string]interface{}{} @@ -1714,6 +2340,23 @@ func flattenAllInstancesConfig(allInstancesConfig *compute.InstanceGroupManagerA return results } +func flattenAllInstancesConfigV2(raw interface{}) []map[string]interface{} { + allInstancesConfig := mapFromInterface(raw) + results := []map[string]interface{}{} + props := map[string]interface{}{} + properties := mapFromInterface(allInstancesConfig["properties"]) + metadata := mapFromInterface(properties["metadata"]) + if len(metadata) > 0 { + props["metadata"] = metadata + } + labels := mapFromInterface(properties["labels"]) + if len(labels) > 0 { + props["labels"] = labels + } + results = append(results, props) + return results +} + func flattenStatus(status *compute.InstanceGroupManagerStatus) []map[string]interface{} { results := []map[string]interface{}{} data := map[string]interface{}{ @@ -1728,6 +2371,21 @@ func flattenStatus(status *compute.InstanceGroupManagerStatus) []map[string]inte return results } +func flattenStatusV2(raw interface{}) []map[string]interface{} { + status := mapFromInterface(raw) + results := []map[string]interface{}{} + data := map[string]interface{}{ + "is_stable": boolFromInterface(status["isStable"]), + "stateful": flattenStatusStatefulV2(status["stateful"]), + "version_target": flattenStatusVersionTargetV2(status["versionTarget"]), + } + if status["allInstancesConfig"] != nil { + data["all_instances_config"] = flattenStatusAllInstancesConfigV2(status["allInstancesConfig"]) + } + results = append(results, data) + return results +} + func flattenStatusStateful(stateful *compute.InstanceGroupManagerStatusStateful) []map[string]interface{} { results := []map[string]interface{}{} data := map[string]interface{}{ @@ -1738,6 +2396,17 @@ func flattenStatusStateful(stateful *compute.InstanceGroupManagerStatusStateful) return results } +func flattenStatusStatefulV2(raw interface{}) []map[string]interface{} { + stateful := mapFromInterface(raw) + results := []map[string]interface{}{} + data := map[string]interface{}{ + "has_stateful_config": boolFromInterface(stateful["hasStatefulConfig"]), + "per_instance_configs": flattenStatusStatefulConfigsV2(stateful["perInstanceConfigs"]), + } + results = append(results, data) + return results +} + func flattenStatusStatefulConfigs(statefulConfigs *compute.InstanceGroupManagerStatusStatefulPerInstanceConfigs) []map[string]interface{} { results := []map[string]interface{}{} data := map[string]interface{}{ @@ -1747,6 +2416,16 @@ func flattenStatusStatefulConfigs(statefulConfigs *compute.InstanceGroupManagerS return results } +func flattenStatusStatefulConfigsV2(raw interface{}) []map[string]interface{} { + statefulConfigs := mapFromInterface(raw) + results := []map[string]interface{}{} + data := map[string]interface{}{ + "all_effective": boolFromInterface(statefulConfigs["allEffective"]), + } + results = append(results, data) + return results +} + func flattenStatusVersionTarget(versionTarget *compute.InstanceGroupManagerStatusVersionTarget) []map[string]interface{} { results := []map[string]interface{}{} data := map[string]interface{}{ @@ -1756,6 +2435,16 @@ func flattenStatusVersionTarget(versionTarget *compute.InstanceGroupManagerStatu return results } +func flattenStatusVersionTargetV2(raw interface{}) []map[string]interface{} { + versionTarget := mapFromInterface(raw) + results := []map[string]interface{}{} + data := map[string]interface{}{ + "is_reached": boolFromInterface(versionTarget["isReached"]), + } + results = append(results, data) + return results +} + func flattenStatusAllInstancesConfig(allInstancesConfig *compute.InstanceGroupManagerStatusAllInstancesConfig) []map[string]interface{} { results := []map[string]interface{}{} data := map[string]interface{}{ @@ -1766,6 +2455,17 @@ func flattenStatusAllInstancesConfig(allInstancesConfig *compute.InstanceGroupMa return results } +func flattenStatusAllInstancesConfigV2(raw interface{}) []map[string]interface{} { + allInstancesConfig := mapFromInterface(raw) + results := []map[string]interface{}{} + data := map[string]interface{}{ + "effective": boolFromInterface(allInstancesConfig["effective"]), + "current_revision": stringFromMap(allInstancesConfig, "currentRevision"), + } + results = append(results, data) + return results +} + func flattenTargetSizePolicy(targetSizePolicy *compute.InstanceGroupManagerTargetSizePolicy) []map[string]interface{} { if targetSizePolicy == nil { return nil @@ -1777,6 +2477,18 @@ func flattenTargetSizePolicy(targetSizePolicy *compute.InstanceGroupManagerTarge } } +func flattenTargetSizePolicyV2(raw interface{}) []map[string]interface{} { + targetSizePolicy := mapFromInterface(raw) + if targetSizePolicy == nil { + return nil + } + return []map[string]interface{}{ + { + "mode": stringFromMap(targetSizePolicy, "mode"), + }, + } +} + func flattenResourcePolicies(resourcePolicies *compute.InstanceGroupManagerResourcePolicies) []map[string]interface{} { results := []map[string]interface{}{} if resourcePolicies != nil { @@ -1788,6 +2500,18 @@ func flattenResourcePolicies(resourcePolicies *compute.InstanceGroupManagerResou return results } +func flattenResourcePoliciesV2(raw interface{}) []map[string]interface{} { + resourcePolicies := mapFromInterface(raw) + results := []map[string]interface{}{} + if resourcePolicies != nil { + data := map[string]interface{}{ + "workload_policy": stringFromMap(resourcePolicies, "workloadPolicy"), + } + 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)