Skip to content

Commit

Permalink
Add stateful_ips to region_per_instance_config and per_instance_config (
Browse files Browse the repository at this point in the history 
#7316) (#5256)

* Add stateful_ips to region_per_instance_config and per_instance_config

* Change network resource name to random strings

* Update update tests, remove is_set for stateful_ips

Signed-off-by: Modular Magician <[email protected]>
  • Loading branch information
@modular-magician
modular-magician authored Feb 27, 2023
1 parent 7b604e0 commit a839621
Show file tree
Hide file tree
Showing 7 changed files with 1,087 additions and 0 deletions.
3 changes: 3 additions & 0 deletions .changelog/7316.txt
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
```release-note:enhancement
compute: added `internal_ip` and `external_ip` to `google_compute_per_instance_config` and `google_compute_region_per_instance_config` (beta)
```
296 changes: 296 additions & 0 deletions google-beta/resource_compute_per_instance_config.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -68,6 +68,78 @@ func ResourceComputePerInstanceConfig() *schema.Resource {
Elem: computePerInstanceConfigPreservedStateDiskSchema(),
// Default schema.HashSchema is used.
},
"external_ip": {
Type: schema.TypeSet,
Optional: true,
Description: `Preserved external IPs defined for this instance. This map is keyed with the name of the network interface.`,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"interface_name": {
Type: schema.TypeString,
Required: true,
},
"auto_delete": {
Type: schema.TypeString,
Optional: true,
ValidateFunc: validateEnum([]string{"NEVER", "ON_PERMANENT_INSTANCE_DELETION", ""}),
Description: `These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted. Default value: "NEVER" Possible values: ["NEVER", "ON_PERMANENT_INSTANCE_DELETION"]`,
Default: "NEVER",
},
"ip_address": {
Type: schema.TypeList,
Optional: true,
Description: `Ip address representation`,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"address": {
Type: schema.TypeString,
Optional: true,
DiffSuppressFunc: compareSelfLinkOrResourceName,
Description: `The URL of the reservation for this IP address.`,
},
},
},
},
},
},
},
"internal_ip": {
Type: schema.TypeSet,
Optional: true,
Description: `Preserved internal IPs defined for this instance. This map is keyed with the name of the network interface.`,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"interface_name": {
Type: schema.TypeString,
Required: true,
},
"auto_delete": {
Type: schema.TypeString,
Optional: true,
ValidateFunc: validateEnum([]string{"NEVER", "ON_PERMANENT_INSTANCE_DELETION", ""}),
Description: `These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted. Default value: "NEVER" Possible values: ["NEVER", "ON_PERMANENT_INSTANCE_DELETION"]`,
Default: "NEVER",
},
"ip_address": {
Type: schema.TypeList,
Optional: true,
Description: `Ip address representation`,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"address": {
Type: schema.TypeString,
Optional: true,
DiffSuppressFunc: compareSelfLinkOrResourceName,
Description: `The URL of the reservation for this IP address.`,
},
},
},
},
},
},
},
"metadata": {
Type: schema.TypeMap,
Optional: true,
Expand Down Expand Up @@ -558,6 +630,10 @@ func flattenNestedComputePerInstanceConfigPreservedState(v interface{}, d *schem
flattenNestedComputePerInstanceConfigPreservedStateMetadata(original["metadata"], d, config)
transformed["disk"] =
flattenNestedComputePerInstanceConfigPreservedStateDisk(original["disks"], d, config)
transformed["internal_ip"] =
flattenNestedComputePerInstanceConfigPreservedStateInternalIp(original["internalIPs"], d, config)
transformed["external_ip"] =
flattenNestedComputePerInstanceConfigPreservedStateExternalIp(original["externalIPs"], d, config)
return []interface{}{transformed}
}
func flattenNestedComputePerInstanceConfigPreservedStateMetadata(v interface{}, d *schema.ResourceData, config *Config) interface{} {
Expand Down Expand Up @@ -586,6 +662,86 @@ func flattenNestedComputePerInstanceConfigPreservedStateDisk(v interface{}, d *s
return transformed
}

func flattenNestedComputePerInstanceConfigPreservedStateInternalIp(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return v
}
l := v.(map[string]interface{})
transformed := make([]interface{}, 0, len(l))
for k, raw := range l {
original := raw.(map[string]interface{})
transformed = append(transformed, map[string]interface{}{
"interface_name": k,
"auto_delete": flattenNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(original["autoDelete"], d, config),
"ip_address": flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(original["ipAddress"], d, config),
})
}
return transformed
}
func flattenNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(v interface{}, d *schema.ResourceData, config *Config) interface{} {
return v
}

func flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return nil
}
original := v.(map[string]interface{})
if len(original) == 0 {
return nil
}
transformed := make(map[string]interface{})
transformed["address"] =
flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(original["address"], d, config)
return []interface{}{transformed}
}
func flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return v
}
return ConvertSelfLinkToV1(v.(string))
}

func flattenNestedComputePerInstanceConfigPreservedStateExternalIp(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return v
}
l := v.(map[string]interface{})
transformed := make([]interface{}, 0, len(l))
for k, raw := range l {
original := raw.(map[string]interface{})
transformed = append(transformed, map[string]interface{}{
"interface_name": k,
"auto_delete": flattenNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(original["autoDelete"], d, config),
"ip_address": flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(original["ipAddress"], d, config),
})
}
return transformed
}
func flattenNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(v interface{}, d *schema.ResourceData, config *Config) interface{} {
return v
}

func flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return nil
}
original := v.(map[string]interface{})
if len(original) == 0 {
return nil
}
transformed := make(map[string]interface{})
transformed["address"] =
flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(original["address"], d, config)
return []interface{}{transformed}
}
func flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return v
}
return ConvertSelfLinkToV1(v.(string))
}

func expandNestedComputePerInstanceConfigName(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
return v, nil
}
Expand Down Expand Up @@ -613,6 +769,20 @@ func expandNestedComputePerInstanceConfigPreservedState(v interface{}, d Terrafo
transformed["disks"] = transformedDisk
}

transformedInternalIp, err := expandNestedComputePerInstanceConfigPreservedStateInternalIp(original["internal_ip"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedInternalIp); val.IsValid() && !isEmptyValue(val) {
transformed["internalIPs"] = transformedInternalIp
}

transformedExternalIp, err := expandNestedComputePerInstanceConfigPreservedStateExternalIp(original["external_ip"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedExternalIp); val.IsValid() && !isEmptyValue(val) {
transformed["externalIPs"] = transformedExternalIp
}

return transformed, nil
}

Expand Down Expand Up @@ -657,6 +827,132 @@ func expandNestedComputePerInstanceConfigPreservedStateDisk(v interface{}, d Ter
return req, nil
}

func expandNestedComputePerInstanceConfigPreservedStateInternalIp(v interface{}, d TerraformResourceData, config *Config) (map[string]interface{}, error) {
if v == nil {
return map[string]interface{}{}, nil
}
m := make(map[string]interface{})
for _, raw := range v.(*schema.Set).List() {
original := raw.(map[string]interface{})
transformed := make(map[string]interface{})

transformedAutoDelete, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(original["auto_delete"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedAutoDelete); val.IsValid() && !isEmptyValue(val) {
transformed["autoDelete"] = transformedAutoDelete
}

transformedIpAddress, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(original["ip_address"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedIpAddress); val.IsValid() && !isEmptyValue(val) {
transformed["ipAddress"] = transformedIpAddress
}

transformedInterfaceName, err := expandString(original["interface_name"], d, config)
if err != nil {
return nil, err
}
m[transformedInterfaceName] = transformed
}
return m, nil
}

func expandNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
return v, nil
}

func expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
l := v.([]interface{})
if len(l) == 0 || l[0] == nil {
return nil, nil
}
raw := l[0]
original := raw.(map[string]interface{})
transformed := make(map[string]interface{})

transformedAddress, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(original["address"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedAddress); val.IsValid() && !isEmptyValue(val) {
transformed["address"] = transformedAddress
}

return transformed, nil
}

func expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
f, err := parseRegionalFieldValue("addresses", v.(string), "project", "region", "zone", d, config, true)
if err != nil {
return nil, fmt.Errorf("Invalid value for address: %s", err)
}
return f.RelativeLink(), nil
}

func expandNestedComputePerInstanceConfigPreservedStateExternalIp(v interface{}, d TerraformResourceData, config *Config) (map[string]interface{}, error) {
if v == nil {
return map[string]interface{}{}, nil
}
m := make(map[string]interface{})
for _, raw := range v.(*schema.Set).List() {
original := raw.(map[string]interface{})
transformed := make(map[string]interface{})

transformedAutoDelete, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(original["auto_delete"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedAutoDelete); val.IsValid() && !isEmptyValue(val) {
transformed["autoDelete"] = transformedAutoDelete
}

transformedIpAddress, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(original["ip_address"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedIpAddress); val.IsValid() && !isEmptyValue(val) {
transformed["ipAddress"] = transformedIpAddress
}

transformedInterfaceName, err := expandString(original["interface_name"], d, config)
if err != nil {
return nil, err
}
m[transformedInterfaceName] = transformed
}
return m, nil
}

func expandNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
return v, nil
}

func expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
l := v.([]interface{})
if len(l) == 0 || l[0] == nil {
return nil, nil
}
raw := l[0]
original := raw.(map[string]interface{})
transformed := make(map[string]interface{})

transformedAddress, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(original["address"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedAddress); val.IsValid() && !isEmptyValue(val) {
transformed["address"] = transformedAddress
}

return transformed, nil
}

func expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
f, err := parseRegionalFieldValue("addresses", v.(string), "project", "region", "zone", d, config, true)
if err != nil {
return nil, fmt.Errorf("Invalid value for address: %s", err)
}
return f.RelativeLink(), nil
}

func resourceComputePerInstanceConfigEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) {
wrappedReq := map[string]interface{}{
"instances": []interface{}{obj},
Expand Down
Loading

0 comments on commit a839621

Please sign in to comment.